From 7f18ed4b9f64c895d5faf5275593c35071bcbf3e Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Sun, 4 Oct 2015 09:01:12 -0700 Subject: [PATCH 01/76] vk: Import header 0.170.2 header LunarG SDK From the LunarG SDK at tag sdk-0.9.1, import vulkan.h as vulkan-0.170.2.h. This header is the first provisional header with the addition of minor fixes. --- include/vulkan/vulkan-0.170.2.h | 3034 +++++++++++++++++++++++++++++++ 1 file changed, 3034 insertions(+) create mode 100644 include/vulkan/vulkan-0.170.2.h diff --git a/include/vulkan/vulkan-0.170.2.h b/include/vulkan/vulkan-0.170.2.h new file mode 100644 index 00000000000..03bcefea50a --- /dev/null +++ b/include/vulkan/vulkan-0.170.2.h @@ -0,0 +1,3034 @@ +#ifndef __vulkan_h_ +#define __vulkan_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* +** 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) + +// Vulkan API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(0, 170, 2) + + +#if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L) + #define VK_NULL_HANDLE nullptr +#else + #define VK_NULL_HANDLE 0 +#endif + + +#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; + + +#if defined(__cplusplus) + #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L) + // The bool operator only works if there are no implicit conversions from an obj to + // a bool-compatible type, which can then be used to unintentionally violate type safety. + // C++11 and above supports the "explicit" keyword on conversion operators to stop this + // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating + // the object handle as a bool in expressions like: + // if (obj) vkDestroy(obj); + #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } + #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ + explicit obj(uint64_t x) : handle(x) { } \ + obj(decltype(nullptr)) : handle(0) { } + #else + #define VK_NONDISP_HANDLE_OPERATOR_BOOL() + #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ + obj(uint64_t x) : handle(x) { } + #endif + #define VK_DEFINE_NONDISP_HANDLE(obj) \ + struct obj { \ + obj() : handle(0) { } \ + VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ + obj& operator =(uint64_t x) { handle = x; return *this; } \ + bool operator==(const obj& other) const { return handle == other.handle; } \ + bool operator!=(const obj& other) const { return handle != other.handle; } \ + bool operator!() const { return !handle; } \ + VK_NONDISP_HANDLE_OPERATOR_BOOL() \ + uint64_t handle; \ + }; +#else + #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj; +#endif + + + +typedef uint32_t VkBool32; +typedef uint32_t VkFlags; +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_HANDLE(VkCmdBuffer) +VK_DEFINE_NONDISP_HANDLE(VkFence) +VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory) +VK_DEFINE_NONDISP_HANDLE(VkBuffer) +VK_DEFINE_NONDISP_HANDLE(VkImage) +VK_DEFINE_NONDISP_HANDLE(VkSemaphore) +VK_DEFINE_NONDISP_HANDLE(VkEvent) +VK_DEFINE_NONDISP_HANDLE(VkQueryPool) +VK_DEFINE_NONDISP_HANDLE(VkBufferView) +VK_DEFINE_NONDISP_HANDLE(VkImageView) +VK_DEFINE_NONDISP_HANDLE(VkShaderModule) +VK_DEFINE_NONDISP_HANDLE(VkShader) +VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) +VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout) +VK_DEFINE_NONDISP_HANDLE(VkRenderPass) +VK_DEFINE_NONDISP_HANDLE(VkPipeline) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NONDISP_HANDLE(VkSampler) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) +VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) +VK_DEFINE_NONDISP_HANDLE(VkCmdPool) + +#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 256 +#define VK_UUID_LENGTH 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME 256 +#define VK_MAX_DESCRIPTION 256 + + +typedef enum { + VK_SUCCESS = 0, + VK_UNSUPPORTED = 1, + VK_NOT_READY = 2, + VK_TIMEOUT = 3, + VK_EVENT_SET = 4, + VK_EVENT_RESET = 5, + VK_INCOMPLETE = 6, + 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_INCOMPATIBLE_DRIVER = -8, + VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum { + VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, + VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, + VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, + VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, + VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, + VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), + VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocType; + +typedef enum { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM = 1, + VK_FORMAT_R4G4_USCALED = 2, + VK_FORMAT_R4G4B4A4_UNORM = 3, + VK_FORMAT_R4G4B4A4_USCALED = 4, + VK_FORMAT_R5G6B5_UNORM = 5, + VK_FORMAT_R5G6B5_USCALED = 6, + VK_FORMAT_R5G5B5A1_UNORM = 7, + VK_FORMAT_R5G5B5A1_USCALED = 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_R8G8B8A8_UNORM = 30, + VK_FORMAT_R8G8B8A8_SNORM = 31, + VK_FORMAT_R8G8B8A8_USCALED = 32, + VK_FORMAT_R8G8B8A8_SSCALED = 33, + VK_FORMAT_R8G8B8A8_UINT = 34, + VK_FORMAT_R8G8B8A8_SINT = 35, + VK_FORMAT_R8G8B8A8_SRGB = 36, + VK_FORMAT_R10G10B10A2_UNORM = 37, + VK_FORMAT_R10G10B10A2_SNORM = 38, + VK_FORMAT_R10G10B10A2_USCALED = 39, + VK_FORMAT_R10G10B10A2_SSCALED = 40, + VK_FORMAT_R10G10B10A2_UINT = 41, + VK_FORMAT_R10G10B10A2_SINT = 42, + VK_FORMAT_R16_UNORM = 43, + VK_FORMAT_R16_SNORM = 44, + VK_FORMAT_R16_USCALED = 45, + VK_FORMAT_R16_SSCALED = 46, + VK_FORMAT_R16_UINT = 47, + VK_FORMAT_R16_SINT = 48, + VK_FORMAT_R16_SFLOAT = 49, + VK_FORMAT_R16G16_UNORM = 50, + VK_FORMAT_R16G16_SNORM = 51, + VK_FORMAT_R16G16_USCALED = 52, + VK_FORMAT_R16G16_SSCALED = 53, + VK_FORMAT_R16G16_UINT = 54, + VK_FORMAT_R16G16_SINT = 55, + VK_FORMAT_R16G16_SFLOAT = 56, + VK_FORMAT_R16G16B16_UNORM = 57, + VK_FORMAT_R16G16B16_SNORM = 58, + VK_FORMAT_R16G16B16_USCALED = 59, + VK_FORMAT_R16G16B16_SSCALED = 60, + VK_FORMAT_R16G16B16_UINT = 61, + VK_FORMAT_R16G16B16_SINT = 62, + VK_FORMAT_R16G16B16_SFLOAT = 63, + VK_FORMAT_R16G16B16A16_UNORM = 64, + VK_FORMAT_R16G16B16A16_SNORM = 65, + VK_FORMAT_R16G16B16A16_USCALED = 66, + VK_FORMAT_R16G16B16A16_SSCALED = 67, + VK_FORMAT_R16G16B16A16_UINT = 68, + VK_FORMAT_R16G16B16A16_SINT = 69, + VK_FORMAT_R16G16B16A16_SFLOAT = 70, + VK_FORMAT_R32_UINT = 71, + VK_FORMAT_R32_SINT = 72, + VK_FORMAT_R32_SFLOAT = 73, + VK_FORMAT_R32G32_UINT = 74, + VK_FORMAT_R32G32_SINT = 75, + VK_FORMAT_R32G32_SFLOAT = 76, + VK_FORMAT_R32G32B32_UINT = 77, + VK_FORMAT_R32G32B32_SINT = 78, + VK_FORMAT_R32G32B32_SFLOAT = 79, + VK_FORMAT_R32G32B32A32_UINT = 80, + VK_FORMAT_R32G32B32A32_SINT = 81, + VK_FORMAT_R32G32B32A32_SFLOAT = 82, + VK_FORMAT_R64_SFLOAT = 83, + VK_FORMAT_R64G64_SFLOAT = 84, + VK_FORMAT_R64G64B64_SFLOAT = 85, + VK_FORMAT_R64G64B64A64_SFLOAT = 86, + VK_FORMAT_R11G11B10_UFLOAT = 87, + VK_FORMAT_R9G9B9E5_UFLOAT = 88, + VK_FORMAT_D16_UNORM = 89, + VK_FORMAT_D24_UNORM_X8 = 90, + VK_FORMAT_D32_SFLOAT = 91, + VK_FORMAT_S8_UINT = 92, + VK_FORMAT_D16_UNORM_S8_UINT = 93, + VK_FORMAT_D24_UNORM_S8_UINT = 94, + VK_FORMAT_D32_SFLOAT_S8_UINT = 95, + VK_FORMAT_BC1_RGB_UNORM = 96, + VK_FORMAT_BC1_RGB_SRGB = 97, + VK_FORMAT_BC1_RGBA_UNORM = 98, + VK_FORMAT_BC1_RGBA_SRGB = 99, + VK_FORMAT_BC2_UNORM = 100, + VK_FORMAT_BC2_SRGB = 101, + VK_FORMAT_BC3_UNORM = 102, + VK_FORMAT_BC3_SRGB = 103, + VK_FORMAT_BC4_UNORM = 104, + VK_FORMAT_BC4_SNORM = 105, + VK_FORMAT_BC5_UNORM = 106, + VK_FORMAT_BC5_SNORM = 107, + VK_FORMAT_BC6H_UFLOAT = 108, + VK_FORMAT_BC6H_SFLOAT = 109, + VK_FORMAT_BC7_UNORM = 110, + VK_FORMAT_BC7_SRGB = 111, + VK_FORMAT_ETC2_R8G8B8_UNORM = 112, + VK_FORMAT_ETC2_R8G8B8_SRGB = 113, + VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, + VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, + VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, + VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, + VK_FORMAT_EAC_R11_UNORM = 118, + VK_FORMAT_EAC_R11_SNORM = 119, + VK_FORMAT_EAC_R11G11_UNORM = 120, + VK_FORMAT_EAC_R11G11_SNORM = 121, + VK_FORMAT_ASTC_4x4_UNORM = 122, + VK_FORMAT_ASTC_4x4_SRGB = 123, + VK_FORMAT_ASTC_5x4_UNORM = 124, + VK_FORMAT_ASTC_5x4_SRGB = 125, + VK_FORMAT_ASTC_5x5_UNORM = 126, + VK_FORMAT_ASTC_5x5_SRGB = 127, + VK_FORMAT_ASTC_6x5_UNORM = 128, + VK_FORMAT_ASTC_6x5_SRGB = 129, + VK_FORMAT_ASTC_6x6_UNORM = 130, + VK_FORMAT_ASTC_6x6_SRGB = 131, + VK_FORMAT_ASTC_8x5_UNORM = 132, + VK_FORMAT_ASTC_8x5_SRGB = 133, + VK_FORMAT_ASTC_8x6_UNORM = 134, + VK_FORMAT_ASTC_8x6_SRGB = 135, + VK_FORMAT_ASTC_8x8_UNORM = 136, + VK_FORMAT_ASTC_8x8_SRGB = 137, + VK_FORMAT_ASTC_10x5_UNORM = 138, + VK_FORMAT_ASTC_10x5_SRGB = 139, + VK_FORMAT_ASTC_10x6_UNORM = 140, + VK_FORMAT_ASTC_10x6_SRGB = 141, + VK_FORMAT_ASTC_10x8_UNORM = 142, + VK_FORMAT_ASTC_10x8_SRGB = 143, + VK_FORMAT_ASTC_10x10_UNORM = 144, + VK_FORMAT_ASTC_10x10_SRGB = 145, + VK_FORMAT_ASTC_12x10_UNORM = 146, + VK_FORMAT_ASTC_12x10_SRGB = 147, + VK_FORMAT_ASTC_12x12_UNORM = 148, + VK_FORMAT_ASTC_12x12_SRGB = 149, + VK_FORMAT_B4G4R4A4_UNORM = 150, + VK_FORMAT_B5G5R5A1_UNORM = 151, + VK_FORMAT_B5G6R5_UNORM = 152, + VK_FORMAT_B5G6R5_USCALED = 153, + VK_FORMAT_B8G8R8_UNORM = 154, + VK_FORMAT_B8G8R8_SNORM = 155, + VK_FORMAT_B8G8R8_USCALED = 156, + VK_FORMAT_B8G8R8_SSCALED = 157, + VK_FORMAT_B8G8R8_UINT = 158, + VK_FORMAT_B8G8R8_SINT = 159, + VK_FORMAT_B8G8R8_SRGB = 160, + VK_FORMAT_B8G8R8A8_UNORM = 161, + VK_FORMAT_B8G8R8A8_SNORM = 162, + VK_FORMAT_B8G8R8A8_USCALED = 163, + VK_FORMAT_B8G8R8A8_SSCALED = 164, + VK_FORMAT_B8G8R8A8_UINT = 165, + VK_FORMAT_B8G8R8A8_SINT = 166, + VK_FORMAT_B8G8R8A8_SRGB = 167, + VK_FORMAT_B10G10R10A2_UNORM = 168, + VK_FORMAT_B10G10R10A2_SNORM = 169, + VK_FORMAT_B10G10R10A2_USCALED = 170, + VK_FORMAT_B10G10R10A2_SSCALED = 171, + VK_FORMAT_B10G10R10A2_UINT = 172, + VK_FORMAT_B10G10R10A2_SINT = 173, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, + VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum { + 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_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum { + VK_IMAGE_TILING_LINEAR = 0, + VK_IMAGE_TILING_OPTIMAL = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum { + 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_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum { + VK_IMAGE_ASPECT_COLOR = 0, + VK_IMAGE_ASPECT_DEPTH = 1, + VK_IMAGE_ASPECT_STENCIL = 2, + VK_IMAGE_ASPECT_METADATA = 3, + VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, + VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA, + VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1), + VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF +} VkImageAspect; + +typedef enum { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, + VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum { + 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_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum { + 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_SOURCE_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, + VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum { + 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_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum { + VK_CHANNEL_SWIZZLE_ZERO = 0, + VK_CHANNEL_SWIZZLE_ONE = 1, + VK_CHANNEL_SWIZZLE_R = 2, + VK_CHANNEL_SWIZZLE_G = 3, + VK_CHANNEL_SWIZZLE_B = 4, + VK_CHANNEL_SWIZZLE_A = 5, + VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, + VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, + VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), + VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkChannelSwizzle; + +typedef enum { + VK_SHADER_STAGE_VERTEX = 0, + VK_SHADER_STAGE_TESS_CONTROL = 1, + VK_SHADER_STAGE_TESS_EVALUATION = 2, + VK_SHADER_STAGE_GEOMETRY = 3, + VK_SHADER_STAGE_FRAGMENT = 4, + VK_SHADER_STAGE_COMPUTE = 5, + VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, + VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, + VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), + VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF +} VkShaderStage; + +typedef enum { + VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, + VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, + VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, + VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), + VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputStepRate; + +typedef enum { + 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_ADJ = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, + VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum { + VK_FILL_MODE_POINTS = 0, + VK_FILL_MODE_WIREFRAME = 1, + VK_FILL_MODE_SOLID = 2, + VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, + VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, + VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), + VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF +} VkFillMode; + +typedef enum { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT = 1, + VK_CULL_MODE_BACK = 2, + VK_CULL_MODE_FRONT_AND_BACK = 3, + VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, + VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, + VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), + VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF +} VkCullMode; + +typedef enum { + VK_FRONT_FACE_CCW = 0, + VK_FRONT_FACE_CW = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, + VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_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_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INC_CLAMP = 3, + VK_STENCIL_OP_DEC_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INC_WRAP = 6, + VK_STENCIL_OP_DEC_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, + VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum { + 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_NOOP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIV = 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_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum { + VK_BLEND_ZERO = 0, + VK_BLEND_ONE = 1, + VK_BLEND_SRC_COLOR = 2, + VK_BLEND_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_DEST_COLOR = 4, + VK_BLEND_ONE_MINUS_DEST_COLOR = 5, + VK_BLEND_SRC_ALPHA = 6, + VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_DEST_ALPHA = 8, + VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, + VK_BLEND_CONSTANT_COLOR = 10, + VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_CONSTANT_ALPHA = 12, + VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_SRC_ALPHA_SATURATE = 14, + VK_BLEND_SRC1_COLOR = 15, + VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_SRC1_ALPHA = 17, + VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, + VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), + VK_BLEND_MAX_ENUM = 0x7FFFFFFF +} VkBlend; + +typedef enum { + 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_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum { + 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_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum { + VK_TEX_FILTER_NEAREST = 0, + VK_TEX_FILTER_LINEAR = 1, + VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, + VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, + VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), + VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkTexFilter; + +typedef enum { + VK_TEX_MIPMAP_MODE_BASE = 0, + VK_TEX_MIPMAP_MODE_NEAREST = 1, + VK_TEX_MIPMAP_MODE_LINEAR = 2, + VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, + VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, + VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), + VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkTexMipmapMode; + +typedef enum { + VK_TEX_ADDRESS_MODE_WRAP = 0, + VK_TEX_ADDRESS_MODE_MIRROR = 1, + VK_TEX_ADDRESS_MODE_CLAMP = 2, + VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3, + VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4, + VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP, + VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER, + VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1), + VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF +} VkTexAddressMode; + +typedef enum { + 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_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum { + 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_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum { + VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, + VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, + VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, + VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, + VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), + VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolUsage; + +typedef enum { + VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, + VK_DESCRIPTOR_SET_USAGE_STATIC = 1, + VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, + VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, + VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), + VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetUsage; + +typedef enum { + 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_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum { + 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_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum { + VK_PIPELINE_BIND_POINT_COMPUTE = 0, + VK_PIPELINE_BIND_POINT_GRAPHICS = 1, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum { + VK_CMD_BUFFER_LEVEL_PRIMARY = 0, + VK_CMD_BUFFER_LEVEL_SECONDARY = 1, + VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, + VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, + VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), + VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCmdBufferLevel; + +typedef enum { + 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_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum { + VK_TIMESTAMP_TYPE_TOP = 0, + VK_TIMESTAMP_TYPE_BOTTOM = 1, + VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, + VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, + VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), + VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkTimestampType; + +typedef enum { + VK_RENDER_PASS_CONTENTS_INLINE = 0, + VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, + VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, + VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, + VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), + VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkRenderPassContents; + + +typedef enum { + 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_SOURCE_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800, +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum { + VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DESTINATION_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, +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum { + 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, +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum { + 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, +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_DMA_BIT = 0x00000004, + VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, + VK_QUEUE_EXTENDED_BIT = 0x40000000, +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum { + VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum { + VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum { + VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum { + VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; + +typedef enum { + VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum { + VK_QUERY_RESULT_DEFAULT = 0, + 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, +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum { + VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DESTINATION_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, +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; + +typedef enum { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum { + VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, + VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, +} VkImageViewCreateFlagBits; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkShaderCreateFlags; + +typedef enum { + VK_CHANNEL_R_BIT = 0x00000001, + VK_CHANNEL_G_BIT = 0x00000002, + VK_CHANNEL_B_BIT = 0x00000004, + VK_CHANNEL_A_BIT = 0x00000008, +} VkChannelFlagBits; +typedef VkFlags VkChannelFlags; + +typedef enum { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; + +typedef enum { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESS_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 = 0x7FFFFFFF, +} VkShaderStageFlagBits; +typedef VkFlags VkShaderStageFlags; + +typedef enum { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum { + VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum { + 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_TESS_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESS_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_HOST_BIT = 0x00002000, + VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, + VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; + +typedef enum { + VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, + VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, + VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, + VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, + VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, +} VkMemoryOutputFlagBits; +typedef VkFlags VkMemoryOutputFlags; + +typedef enum { + VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, + VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, + VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, + VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, + VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, + VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, + VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, + VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, + VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, + VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, +} VkMemoryInputFlagBits; +typedef VkFlags VkMemoryInputFlags; + +typedef enum { + VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, +} VkCmdPoolCreateFlagBits; +typedef VkFlags VkCmdPoolCreateFlags; + +typedef enum { + VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, +} VkCmdPoolResetFlagBits; +typedef VkFlags VkCmdPoolResetFlags; +typedef VkFlags VkCmdBufferCreateFlags; + +typedef enum { + VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, + VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, + VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, + VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, + VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, +} VkCmdBufferOptimizeFlagBits; +typedef VkFlags VkCmdBufferOptimizeFlags; + +typedef enum { + VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, +} VkCmdBufferResetFlagBits; +typedef VkFlags VkCmdBufferResetFlags; + +typedef enum { + VK_STENCIL_FACE_NONE = 0, + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + +typedef enum { + VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef void* (VKAPI *PFN_vkAllocFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocType allocType); + +typedef void (VKAPI *PFN_vkFreeFunction)( + void* pUserData, + void* pMem); + +typedef void (VKAPI *PFN_vkVoidFunction)(void); + +typedef struct { + VkStructureType sType; + const void* pNext; + const char* pAppName; + uint32_t appVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct { + void* pUserData; + PFN_vkAllocFunction pfnAlloc; + PFN_vkFreeFunction pfnFree; +} VkAllocCallbacks; + +typedef struct { + VkStructureType sType; + const void* pNext; + const VkApplicationInfo* pAppInfo; + const VkAllocCallbacks* pAllocCb; + uint32_t layerCount; + const char*const* ppEnabledLayerNames; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSourceBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 depthClip; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryNonConservative; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexSideEffects; + VkBool32 tessellationSideEffects; + VkBool32 geometrySideEffects; + VkBool32 fragmentSideEffects; + VkBool32 shaderTessellationPointSize; + VkBool32 shaderGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLOD; + VkBool32 alphaToOne; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; +} VkPhysicalDeviceFeatures; + +typedef struct { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct { + int32_t width; + int32_t height; + int32_t depth; +} VkExtent3D; + +typedef struct { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArraySize; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + VkSampleCountFlags sampleCounts; + uint32_t maxTexelBufferSize; + uint32_t maxUniformBufferSize; + uint32_t maxStorageBufferSize; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessGenLevel; + uint32_t maxTessPatchSize; + uint32_t maxTessControlPerVertexInputComponents; + uint32_t maxTessControlPerVertexOutputComponents; + uint32_t maxTessControlPerPatchOutputComponents; + uint32_t maxTessControlTotalOutputComponents; + uint32_t maxTessEvaluationInputComponents; + uint32_t maxTessEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputBuffers; + uint32_t maxFragmentDualSourceBuffers; + 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 maxDrawIndirectInstanceCount; + VkBool32 primitiveRestartForPatches; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + uint32_t minMemoryMapAlignment; + uint32_t minTexelBufferOffsetAlignment; + uint32_t minUniformBufferOffsetAlignment; + uint32_t minStorageBufferOffsetAlignment; + uint32_t minTexelOffset; + uint32_t maxTexelOffset; + uint32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + uint32_t maxFramebufferColorSamples; + uint32_t maxFramebufferDepthSamples; + uint32_t maxFramebufferStencilSamples; + uint32_t maxColorAttachments; + uint32_t maxSampledImageColorSamples; + uint32_t maxSampledImageDepthSamples; + uint32_t maxSampledImageIntegerSamples; + uint32_t maxStorageImageSamples; + uint32_t maxSampleMaskWords; + uint64_t timestampFrequency; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; +} VkPhysicalDeviceLimits; + +typedef struct { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMSBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResident; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorId; + uint32_t deviceId; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; + uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct { + VkQueueFlags queueFlags; + uint32_t queueCount; + VkBool32 supportsTimestamps; +} VkQueueFamilyProperties; + +typedef struct { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t queueCount; +} VkDeviceQueueCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueRecordCount; + const VkDeviceQueueCreateInfo* pRequestedQueues; + uint32_t layerCount; + const char*const* ppEnabledLayerNames; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct { + char extName[VK_MAX_EXTENSION_NAME]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct { + char layerName[VK_MAX_EXTENSION_NAME]; + uint32_t specVersion; + uint32_t implVersion; + char description[VK_MAX_DESCRIPTION]; +} VkLayerProperties; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceMemory mem; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct { + VkImageAspect aspect; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct { + VkSparseImageFormatProperties formatProps; + uint32_t imageMipTailStartLOD; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct { + VkDeviceSize rangeOffset; + VkDeviceSize rangeSize; + VkDeviceSize memOffset; + VkDeviceMemory mem; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBindInfo; + +typedef struct { + VkImageAspect aspect; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceSize memOffset; + VkDeviceMemory mem; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBindInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkQueryType queryType; + uint32_t slots; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkBufferCreateFlags flags; + VkSharingMode sharingMode; + uint32_t queueFamilyCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arraySize; + uint32_t samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + VkSharingMode sharingMode; + uint32_t queueFamilyCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct { + VkChannelSwizzle r; + VkChannelSwizzle g; + VkChannelSwizzle b; + VkChannelSwizzle a; +} VkChannelMapping; + +typedef struct { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t mipLevels; + uint32_t baseArrayLayer; + uint32_t arraySize; +} VkImageSubresourceRange; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkChannelMapping channels; + VkImageSubresourceRange subresourceRange; + VkImageViewCreateFlags flags; +} VkImageViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + size_t codeSize; + const void* pCode; + VkShaderModuleCreateFlags flags; +} VkShaderModuleCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkShaderModule module; + const char* pName; + VkShaderCreateFlags flags; + VkShaderStage stage; +} VkShaderCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + size_t initialSize; + const void* initialData; + size_t maxSize; +} VkPipelineCacheCreateInfo; + +typedef struct { + uint32_t constantId; + size_t size; + uint32_t offset; +} VkSpecializationMapEntry; + +typedef struct { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMap; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkShaderStage stage; + VkShader shader; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct { + uint32_t binding; + uint32_t strideInBytes; + VkVertexInputStepRate stepRate; +} VkVertexInputBindingDescription; + +typedef struct { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offsetInBytes; +} VkVertexInputAttributeDescription; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t attributeCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct { + float originX; + float originY; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct { + int32_t width; + int32_t height; +} VkExtent2D; + +typedef struct { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 depthClipEnable; + VkBool32 rasterizerDiscardEnable; + VkFillMode fillMode; + VkCullMode cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBias; + float depthBiasClamp; + float slopeScaledDepthBias; + float lineWidth; +} VkPipelineRasterStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t rasterSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct { + VkStencilOp stencilFailOp; + VkStencilOp stencilPassOp; + VkStencilOp stencilDepthFailOp; + VkCompareOp stencilCompareOp; + uint32_t stencilCompareMask; + uint32_t stencilWriteMask; + uint32_t stencilReference; +} VkStencilOpState; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct { + VkBool32 blendEnable; + VkBlend srcBlendColor; + VkBlend destBlendColor; + VkBlendOp blendOpColor; + VkBlend srcBlendAlpha; + VkBlend destBlendAlpha; + VkBlendOp blendOpAlpha; + VkChannelFlags channelWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConst[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterStateCreateInfo* pRasterState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineCreateFlags flags; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateInfo stage; + VkPipelineCreateFlags flags; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct { + VkShaderStageFlags stageFlags; + uint32_t start; + uint32_t length; +} VkPushConstantRange; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkTexFilter magFilter; + VkTexFilter minFilter; + VkTexMipmapMode mipMode; + VkTexAddressMode addressModeU; + VkTexAddressMode addressModeV; + VkTexAddressMode addressModeW; + float mipLodBias; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct { + VkDescriptorType descriptorType; + uint32_t arraySize; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t count; + const VkDescriptorSetLayoutBinding* pBinding; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct { + VkDescriptorType type; + uint32_t count; +} VkDescriptorTypeCount; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolUsage poolUsage; + uint32_t maxSets; + uint32_t count; + const VkDescriptorTypeCount* pTypeCount; +} VkDescriptorPoolCreateInfo; + +typedef struct { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct { + VkBufferView bufferView; + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; + VkDescriptorBufferInfo bufferInfo; +} VkDescriptorInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorSet destSet; + uint32_t destBinding; + uint32_t destArrayElement; + uint32_t count; + VkDescriptorType descriptorType; + const VkDescriptorInfo* pDescriptors; +} VkWriteDescriptorSet; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet destSet; + uint32_t destBinding; + uint32_t destArrayElement; + uint32_t count; +} VkCopyDescriptorSet; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkFormat format; + uint32_t samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; + VkAttachmentDescriptionFlags flags; +} VkAttachmentDescription; + +typedef struct { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkSubpassDescriptionFlags flags; + uint32_t inputCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + VkAttachmentReference depthStencilAttachment; + uint32_t preserveCount; + const VkAttachmentReference* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t destSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags destStageMask; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + VkBool32 byRegion; +} VkSubpassDependency; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkCmdPoolCreateFlags flags; +} VkCmdPoolCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkCmdPool cmdPool; + VkCmdBufferLevel level; + VkCmdBufferCreateFlags flags; +} VkCmdBufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkCmdBufferOptimizeFlags flags; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; +} VkCmdBufferBeginInfo; + +typedef struct { + VkDeviceSize srcOffset; + VkDeviceSize destOffset; + VkDeviceSize copySize; +} VkBufferCopy; + +typedef struct { + VkImageAspect aspect; + uint32_t mipLevel; + uint32_t arrayLayer; + uint32_t arraySize; +} VkImageSubresourceCopy; + +typedef struct { + VkImageSubresourceCopy srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceCopy destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct { + VkImageSubresourceCopy srcSubresource; + VkOffset3D srcOffset; + VkExtent3D srcExtent; + VkImageSubresourceCopy destSubresource; + VkOffset3D destOffset; + VkExtent3D destExtent; +} VkImageBlit; + +typedef struct { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceCopy imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef struct { + VkOffset3D offset; + VkExtent3D extent; +} VkRect3D; + +typedef struct { + VkImageSubresourceCopy srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceCopy destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef union { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + uint32_t srcQueueFamilyIndex; + uint32_t destQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCmd; + +typedef struct { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCmd; + +typedef struct { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCmd; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t destQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; +} VkMemoryBarrier; + + +typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); +typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); +typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); +typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); +typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); +typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); +typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); +typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); +typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); +typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); +typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); +typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); +typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); +typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); +typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); +typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); +typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); +typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); +typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); +typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); +typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); +typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); +typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); +typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); +typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); +typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); +typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); +typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); +typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); +typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); +typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); +typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); +typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); +typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); +typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); +typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); +typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); +typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); +typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); +typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); +typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); +typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); +typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); +typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth); +typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias); +typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]); +typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); +typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); +typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); +typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); +typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); +typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); +typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); +typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); +typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); +typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); +typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); +typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); +typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); +typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents); +typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); +typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); + +#ifdef VK_PROTOTYPES +VkResult VKAPI vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + VkInstance* pInstance); + +void VKAPI vkDestroyInstance( + VkInstance instance); + +VkResult VKAPI vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VkResult VKAPI vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VkResult VKAPI vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VkResult VKAPI vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VkResult VKAPI vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice); + +void VKAPI vkDestroyDevice( + VkDevice device); + +VkResult VKAPI vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult VKAPI vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult VKAPI vkEnumerateInstanceLayerProperties( + uint32_t* pCount, + VkLayerProperties* pProperties); + +VkResult VKAPI vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pCount, + VkLayerProperties* pProperties); + +VkResult VKAPI vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VkResult VKAPI vkQueueSubmit( + VkQueue queue, + uint32_t cmdBufferCount, + const VkCmdBuffer* pCmdBuffers, + VkFence fence); + +VkResult VKAPI vkQueueWaitIdle( + VkQueue queue); + +VkResult VKAPI vkDeviceWaitIdle( + VkDevice device); + +VkResult VKAPI vkAllocMemory( + VkDevice device, + const VkMemoryAllocInfo* pAllocInfo, + VkDeviceMemory* pMem); + +void VKAPI vkFreeMemory( + VkDevice device, + VkDeviceMemory mem); + +VkResult VKAPI vkMapMemory( + VkDevice device, + VkDeviceMemory mem, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +void VKAPI vkUnmapMemory( + VkDevice device, + VkDeviceMemory mem); + +VkResult VKAPI vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges); + +VkResult VKAPI vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges); + +VkResult VKAPI vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VkResult VKAPI vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory mem, + VkDeviceSize memOffset); + +VkResult VKAPI vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory mem, + VkDeviceSize memOffset); + +VkResult VKAPI vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VkResult VKAPI vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VkResult VKAPI vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pNumRequirements, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + uint32_t samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pNumProperties, + VkSparseImageFormatProperties* pProperties); + +VkResult VKAPI vkQueueBindSparseBufferMemory( + VkQueue queue, + VkBuffer buffer, + uint32_t numBindings, + const VkSparseMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkQueueBindSparseImageOpaqueMemory( + VkQueue queue, + VkImage image, + uint32_t numBindings, + const VkSparseMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkQueueBindSparseImageMemory( + VkQueue queue, + VkImage image, + uint32_t numBindings, + const VkSparseImageMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence); + +void VKAPI vkDestroyFence( + VkDevice device, + VkFence fence); + +VkResult VKAPI vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VkResult VKAPI vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VkResult VKAPI vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VkResult VKAPI vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + VkSemaphore* pSemaphore); + +void VKAPI vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore); + +VkResult VKAPI vkQueueSignalSemaphore( + VkQueue queue, + VkSemaphore semaphore); + +VkResult VKAPI vkQueueWaitSemaphore( + VkQueue queue, + VkSemaphore semaphore); + +VkResult VKAPI vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + VkEvent* pEvent); + +void VKAPI vkDestroyEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkGetEventStatus( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkSetEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkResetEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool); + +void VKAPI vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool); + +VkResult VKAPI vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + size_t* pDataSize, + void* pData, + VkQueryResultFlags flags); + +VkResult VKAPI vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + VkBuffer* pBuffer); + +void VKAPI vkDestroyBuffer( + VkDevice device, + VkBuffer buffer); + +VkResult VKAPI vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + VkBufferView* pView); + +void VKAPI vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView); + +VkResult VKAPI vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + VkImage* pImage); + +void VKAPI vkDestroyImage( + VkDevice device, + VkImage image); + +VkResult VKAPI vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VkResult VKAPI vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + VkImageView* pView); + +void VKAPI vkDestroyImageView( + VkDevice device, + VkImageView imageView); + +VkResult VKAPI vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModule* pShaderModule); + +void VKAPI vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule); + +VkResult VKAPI vkCreateShader( + VkDevice device, + const VkShaderCreateInfo* pCreateInfo, + VkShader* pShader); + +void VKAPI vkDestroyShader( + VkDevice device, + VkShader shader); + +VkResult VKAPI vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + VkPipelineCache* pPipelineCache); + +void VKAPI vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache); + +size_t VKAPI vkGetPipelineCacheSize( + VkDevice device, + VkPipelineCache pipelineCache); + +VkResult VKAPI vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + void* pData); + +VkResult VKAPI vkMergePipelineCaches( + VkDevice device, + VkPipelineCache destCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VkResult VKAPI vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +VkResult VKAPI vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkComputePipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +void VKAPI vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline); + +VkResult VKAPI vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + VkPipelineLayout* pPipelineLayout); + +void VKAPI vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout); + +VkResult VKAPI vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + VkSampler* pSampler); + +void VKAPI vkDestroySampler( + VkDevice device, + VkSampler sampler); + +VkResult VKAPI vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayout* pSetLayout); + +void VKAPI vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout); + +VkResult VKAPI vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + VkDescriptorPool* pDescriptorPool); + +void VKAPI vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool); + +VkResult VKAPI vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool); + +VkResult VKAPI vkAllocDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorSetUsage setUsage, + uint32_t count, + const VkDescriptorSetLayout* pSetLayouts, + VkDescriptorSet* pDescriptorSets); + +VkResult VKAPI vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t count, + const VkDescriptorSet* pDescriptorSets); + +void VKAPI vkUpdateDescriptorSets( + VkDevice device, + uint32_t writeCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t copyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VkResult VKAPI vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + VkFramebuffer* pFramebuffer); + +void VKAPI vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer); + +VkResult VKAPI vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + VkRenderPass* pRenderPass); + +void VKAPI vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass); + +VkResult VKAPI vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VkResult VKAPI vkCreateCommandPool( + VkDevice device, + const VkCmdPoolCreateInfo* pCreateInfo, + VkCmdPool* pCmdPool); + +void VKAPI vkDestroyCommandPool( + VkDevice device, + VkCmdPool cmdPool); + +VkResult VKAPI vkResetCommandPool( + VkDevice device, + VkCmdPool cmdPool, + VkCmdPoolResetFlags flags); + +VkResult VKAPI vkCreateCommandBuffer( + VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer); + +void VKAPI vkDestroyCommandBuffer( + VkDevice device, + VkCmdBuffer commandBuffer); + +VkResult VKAPI vkBeginCommandBuffer( + VkCmdBuffer cmdBuffer, + const VkCmdBufferBeginInfo* pBeginInfo); + +VkResult VKAPI vkEndCommandBuffer( + VkCmdBuffer cmdBuffer); + +VkResult VKAPI vkResetCommandBuffer( + VkCmdBuffer cmdBuffer, + VkCmdBufferResetFlags flags); + +void VKAPI vkCmdBindPipeline( + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +void VKAPI vkCmdSetViewport( + VkCmdBuffer cmdBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +void VKAPI vkCmdSetScissor( + VkCmdBuffer cmdBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +void VKAPI vkCmdSetLineWidth( + VkCmdBuffer cmdBuffer, + float lineWidth); + +void VKAPI vkCmdSetDepthBias( + VkCmdBuffer cmdBuffer, + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias); + +void VKAPI vkCmdSetBlendConstants( + VkCmdBuffer cmdBuffer, + const float blendConst[4]); + +void VKAPI vkCmdSetDepthBounds( + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds); + +void VKAPI vkCmdSetStencilCompareMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask); + +void VKAPI vkCmdSetStencilWriteMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask); + +void VKAPI vkCmdSetStencilReference( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilReference); + +void VKAPI vkCmdBindDescriptorSets( + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +void VKAPI vkCmdBindIndexBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +void VKAPI vkCmdBindVertexBuffers( + VkCmdBuffer cmdBuffer, + uint32_t startBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +void VKAPI vkCmdDraw( + VkCmdBuffer cmdBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +void VKAPI vkCmdDrawIndexed( + VkCmdBuffer cmdBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +void VKAPI vkCmdDrawIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t count, + uint32_t stride); + +void VKAPI vkCmdDrawIndexedIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t count, + uint32_t stride); + +void VKAPI vkCmdDispatch( + VkCmdBuffer cmdBuffer, + uint32_t x, + uint32_t y, + uint32_t z); + +void VKAPI vkCmdDispatchIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +void VKAPI vkCmdCopyBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkBuffer destBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +void VKAPI vkCmdCopyImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +void VKAPI vkCmdBlitImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkTexFilter filter); + +void VKAPI vkCmdCopyBufferToImage( + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +void VKAPI vkCmdCopyImageToBuffer( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +void VKAPI vkCmdUpdateBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize dataSize, + const uint32_t* pData); + +void VKAPI vkCmdFillBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize fillSize, + uint32_t data); + +void VKAPI vkCmdClearColorImage( + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +void VKAPI vkCmdClearDepthStencilImage( + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +void VKAPI vkCmdClearColorAttachment( + VkCmdBuffer cmdBuffer, + uint32_t colorAttachment, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rectCount, + const VkRect3D* pRects); + +void VKAPI vkCmdClearDepthStencilAttachment( + VkCmdBuffer cmdBuffer, + VkImageAspectFlags aspectMask, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rectCount, + const VkRect3D* pRects); + +void VKAPI vkCmdResolveImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +void VKAPI vkCmdSetEvent( + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +void VKAPI vkCmdResetEvent( + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +void VKAPI vkCmdWaitEvents( + VkCmdBuffer cmdBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + uint32_t memBarrierCount, + const void* const* ppMemBarriers); + +void VKAPI vkCmdPipelineBarrier( + VkCmdBuffer cmdBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + VkBool32 byRegion, + uint32_t memBarrierCount, + const void* const* ppMemBarriers); + +void VKAPI vkCmdBeginQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot, + VkQueryControlFlags flags); + +void VKAPI vkCmdEndQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot); + +void VKAPI vkCmdResetQueryPool( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount); + +void VKAPI vkCmdWriteTimestamp( + VkCmdBuffer cmdBuffer, + VkTimestampType timestampType, + VkBuffer destBuffer, + VkDeviceSize destOffset); + +void VKAPI vkCmdCopyQueryPoolResults( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize destStride, + VkQueryResultFlags flags); + +void VKAPI vkCmdPushConstants( + VkCmdBuffer cmdBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t start, + uint32_t length, + const void* values); + +void VKAPI vkCmdBeginRenderPass( + VkCmdBuffer cmdBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkRenderPassContents contents); + +void VKAPI vkCmdNextSubpass( + VkCmdBuffer cmdBuffer, + VkRenderPassContents contents); + +void VKAPI vkCmdEndRenderPass( + VkCmdBuffer cmdBuffer); + +void VKAPI vkCmdExecuteCommands( + VkCmdBuffer cmdBuffer, + uint32_t cmdBuffersCount, + const VkCmdBuffer* pCmdBuffers); +#endif + +#ifdef __cplusplus +} +#endif + +#endif From 216d9f248de3c4188ae9d6aae5c4fdfcd46ce00e Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Sun, 4 Oct 2015 09:03:13 -0700 Subject: [PATCH 02/76] vk: Copy current header to vulkan-0.138.2.h While upgrading Mesa to the new 0.170.2 API, it's convenient to have all three headers available in the tree: - vulkan-0.138.2.h, the old one - vulkan-0.170.2.h, the new one - vulkan.h, the one in transition --- include/vulkan/vulkan-0.138.2.h | 3054 +++++++++++++++++++++++++++++++ 1 file changed, 3054 insertions(+) create mode 100644 include/vulkan/vulkan-0.138.2.h diff --git a/include/vulkan/vulkan-0.138.2.h b/include/vulkan/vulkan-0.138.2.h new file mode 100644 index 00000000000..9877233bfeb --- /dev/null +++ b/include/vulkan/vulkan-0.138.2.h @@ -0,0 +1,3054 @@ +#ifndef __vulkan_h_ +#define __vulkan_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* +** 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) + +// Vulkan API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(0, 138, 2) + + +#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; + + +#if defined(__cplusplus) + #if (_MSC_VER >= 1800 || __cplusplus >= 201103L) + // The bool operator only works if there are no implicit conversions from an obj to + // a bool-compatible type, which can then be used to unintentionally violate type safety. + // C++11 and above supports the "explicit" keyword on conversion operators to stop this + // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating + // the object handle as a bool in expressions like: + // if (obj) vkDestroy(obj); + #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } + #else + #define VK_NONDISP_HANDLE_OPERATOR_BOOL() + #endif + #define VK_DEFINE_NONDISP_HANDLE(obj) \ + struct obj { \ + obj() : handle(0) { } \ + obj(uint64_t x) : handle(x) { } \ + obj& operator =(uint64_t x) { handle = x; return *this; } \ + bool operator==(const obj& other) const { return handle == other.handle; } \ + bool operator!=(const obj& other) const { return handle != other.handle; } \ + bool operator!() const { return !handle; } \ + VK_NONDISP_HANDLE_OPERATOR_BOOL() \ + uint64_t handle; \ + }; +#else + #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj; +#endif + + + +#define VK_LOD_CLAMP_NONE MAX_FLOAT +#define VK_LAST_MIP_LEVEL UINT32_MAX +#define VK_LAST_ARRAY_SLICE UINT32_MAX +#define VK_WHOLE_SIZE UINT64_MAX +#define VK_ATTACHMENT_UNUSED UINT32_MAX +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_NULL_HANDLE 0 +#define VK_MAX_PHYSICAL_DEVICE_NAME 256 +#define VK_UUID_LENGTH 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME 256 +#define VK_MAX_DESCRIPTION 256 + +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_HANDLE(VkCmdBuffer) +VK_DEFINE_NONDISP_HANDLE(VkFence) +VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory) +VK_DEFINE_NONDISP_HANDLE(VkBuffer) +VK_DEFINE_NONDISP_HANDLE(VkImage) +VK_DEFINE_NONDISP_HANDLE(VkSemaphore) +VK_DEFINE_NONDISP_HANDLE(VkEvent) +VK_DEFINE_NONDISP_HANDLE(VkQueryPool) +VK_DEFINE_NONDISP_HANDLE(VkBufferView) +VK_DEFINE_NONDISP_HANDLE(VkImageView) +VK_DEFINE_NONDISP_HANDLE(VkAttachmentView) +VK_DEFINE_NONDISP_HANDLE(VkShaderModule) +VK_DEFINE_NONDISP_HANDLE(VkShader) +VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) +VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout) +VK_DEFINE_NONDISP_HANDLE(VkRenderPass) +VK_DEFINE_NONDISP_HANDLE(VkPipeline) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NONDISP_HANDLE(VkSampler) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) +VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) +VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) +VK_DEFINE_NONDISP_HANDLE(VkCmdPool) + + +typedef enum { + VK_SUCCESS = 0, + VK_UNSUPPORTED = 1, + VK_NOT_READY = 2, + VK_TIMEOUT = 3, + VK_EVENT_SET = 4, + VK_EVENT_RESET = 5, + VK_INCOMPLETE = 6, + VK_ERROR_UNKNOWN = -1, + VK_ERROR_UNAVAILABLE = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_OUT_OF_HOST_MEMORY = -4, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -5, + VK_ERROR_DEVICE_ALREADY_CREATED = -6, + VK_ERROR_DEVICE_LOST = -7, + VK_ERROR_INVALID_POINTER = -8, + VK_ERROR_INVALID_VALUE = -9, + VK_ERROR_INVALID_HANDLE = -10, + VK_ERROR_INVALID_ORDINAL = -11, + VK_ERROR_INVALID_MEMORY_SIZE = -12, + VK_ERROR_INVALID_EXTENSION = -13, + VK_ERROR_INVALID_FLAGS = -14, + VK_ERROR_INVALID_ALIGNMENT = -15, + VK_ERROR_INVALID_FORMAT = -16, + VK_ERROR_INVALID_IMAGE = -17, + VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18, + VK_ERROR_INVALID_QUEUE_TYPE = -19, + VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -20, + VK_ERROR_BAD_SHADER_CODE = -21, + VK_ERROR_BAD_PIPELINE_DATA = -22, + VK_ERROR_NOT_MAPPABLE = -23, + VK_ERROR_MEMORY_MAP_FAILED = -24, + VK_ERROR_MEMORY_UNMAP_FAILED = -25, + VK_ERROR_INCOMPATIBLE_DEVICE = -26, + VK_ERROR_INCOMPATIBLE_DRIVER = -27, + VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -28, + VK_ERROR_BUILDING_COMMAND_BUFFER = -29, + VK_ERROR_MEMORY_NOT_BOUND = -30, + VK_ERROR_INCOMPATIBLE_QUEUE = -31, + VK_ERROR_INVALID_LAYER = -32, + VK_RESULT_BEGIN_RANGE = VK_ERROR_INVALID_LAYER, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48, + VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, + VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum { + VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, + VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, + VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, + VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, + VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, + VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), + VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocType; + +typedef enum { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM = 1, + VK_FORMAT_R4G4_USCALED = 2, + VK_FORMAT_R4G4B4A4_UNORM = 3, + VK_FORMAT_R4G4B4A4_USCALED = 4, + VK_FORMAT_R5G6B5_UNORM = 5, + VK_FORMAT_R5G6B5_USCALED = 6, + VK_FORMAT_R5G5B5A1_UNORM = 7, + VK_FORMAT_R5G5B5A1_USCALED = 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_R8G8B8A8_UNORM = 30, + VK_FORMAT_R8G8B8A8_SNORM = 31, + VK_FORMAT_R8G8B8A8_USCALED = 32, + VK_FORMAT_R8G8B8A8_SSCALED = 33, + VK_FORMAT_R8G8B8A8_UINT = 34, + VK_FORMAT_R8G8B8A8_SINT = 35, + VK_FORMAT_R8G8B8A8_SRGB = 36, + VK_FORMAT_R10G10B10A2_UNORM = 37, + VK_FORMAT_R10G10B10A2_SNORM = 38, + VK_FORMAT_R10G10B10A2_USCALED = 39, + VK_FORMAT_R10G10B10A2_SSCALED = 40, + VK_FORMAT_R10G10B10A2_UINT = 41, + VK_FORMAT_R10G10B10A2_SINT = 42, + VK_FORMAT_R16_UNORM = 43, + VK_FORMAT_R16_SNORM = 44, + VK_FORMAT_R16_USCALED = 45, + VK_FORMAT_R16_SSCALED = 46, + VK_FORMAT_R16_UINT = 47, + VK_FORMAT_R16_SINT = 48, + VK_FORMAT_R16_SFLOAT = 49, + VK_FORMAT_R16G16_UNORM = 50, + VK_FORMAT_R16G16_SNORM = 51, + VK_FORMAT_R16G16_USCALED = 52, + VK_FORMAT_R16G16_SSCALED = 53, + VK_FORMAT_R16G16_UINT = 54, + VK_FORMAT_R16G16_SINT = 55, + VK_FORMAT_R16G16_SFLOAT = 56, + VK_FORMAT_R16G16B16_UNORM = 57, + VK_FORMAT_R16G16B16_SNORM = 58, + VK_FORMAT_R16G16B16_USCALED = 59, + VK_FORMAT_R16G16B16_SSCALED = 60, + VK_FORMAT_R16G16B16_UINT = 61, + VK_FORMAT_R16G16B16_SINT = 62, + VK_FORMAT_R16G16B16_SFLOAT = 63, + VK_FORMAT_R16G16B16A16_UNORM = 64, + VK_FORMAT_R16G16B16A16_SNORM = 65, + VK_FORMAT_R16G16B16A16_USCALED = 66, + VK_FORMAT_R16G16B16A16_SSCALED = 67, + VK_FORMAT_R16G16B16A16_UINT = 68, + VK_FORMAT_R16G16B16A16_SINT = 69, + VK_FORMAT_R16G16B16A16_SFLOAT = 70, + VK_FORMAT_R32_UINT = 71, + VK_FORMAT_R32_SINT = 72, + VK_FORMAT_R32_SFLOAT = 73, + VK_FORMAT_R32G32_UINT = 74, + VK_FORMAT_R32G32_SINT = 75, + VK_FORMAT_R32G32_SFLOAT = 76, + VK_FORMAT_R32G32B32_UINT = 77, + VK_FORMAT_R32G32B32_SINT = 78, + VK_FORMAT_R32G32B32_SFLOAT = 79, + VK_FORMAT_R32G32B32A32_UINT = 80, + VK_FORMAT_R32G32B32A32_SINT = 81, + VK_FORMAT_R32G32B32A32_SFLOAT = 82, + VK_FORMAT_R64_SFLOAT = 83, + VK_FORMAT_R64G64_SFLOAT = 84, + VK_FORMAT_R64G64B64_SFLOAT = 85, + VK_FORMAT_R64G64B64A64_SFLOAT = 86, + VK_FORMAT_R11G11B10_UFLOAT = 87, + VK_FORMAT_R9G9B9E5_UFLOAT = 88, + VK_FORMAT_D16_UNORM = 89, + VK_FORMAT_D24_UNORM = 90, + VK_FORMAT_D32_SFLOAT = 91, + VK_FORMAT_S8_UINT = 92, + VK_FORMAT_D16_UNORM_S8_UINT = 93, + VK_FORMAT_D24_UNORM_S8_UINT = 94, + VK_FORMAT_D32_SFLOAT_S8_UINT = 95, + VK_FORMAT_BC1_RGB_UNORM = 96, + VK_FORMAT_BC1_RGB_SRGB = 97, + VK_FORMAT_BC1_RGBA_UNORM = 98, + VK_FORMAT_BC1_RGBA_SRGB = 99, + VK_FORMAT_BC2_UNORM = 100, + VK_FORMAT_BC2_SRGB = 101, + VK_FORMAT_BC3_UNORM = 102, + VK_FORMAT_BC3_SRGB = 103, + VK_FORMAT_BC4_UNORM = 104, + VK_FORMAT_BC4_SNORM = 105, + VK_FORMAT_BC5_UNORM = 106, + VK_FORMAT_BC5_SNORM = 107, + VK_FORMAT_BC6H_UFLOAT = 108, + VK_FORMAT_BC6H_SFLOAT = 109, + VK_FORMAT_BC7_UNORM = 110, + VK_FORMAT_BC7_SRGB = 111, + VK_FORMAT_ETC2_R8G8B8_UNORM = 112, + VK_FORMAT_ETC2_R8G8B8_SRGB = 113, + VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, + VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, + VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, + VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, + VK_FORMAT_EAC_R11_UNORM = 118, + VK_FORMAT_EAC_R11_SNORM = 119, + VK_FORMAT_EAC_R11G11_UNORM = 120, + VK_FORMAT_EAC_R11G11_SNORM = 121, + VK_FORMAT_ASTC_4x4_UNORM = 122, + VK_FORMAT_ASTC_4x4_SRGB = 123, + VK_FORMAT_ASTC_5x4_UNORM = 124, + VK_FORMAT_ASTC_5x4_SRGB = 125, + VK_FORMAT_ASTC_5x5_UNORM = 126, + VK_FORMAT_ASTC_5x5_SRGB = 127, + VK_FORMAT_ASTC_6x5_UNORM = 128, + VK_FORMAT_ASTC_6x5_SRGB = 129, + VK_FORMAT_ASTC_6x6_UNORM = 130, + VK_FORMAT_ASTC_6x6_SRGB = 131, + VK_FORMAT_ASTC_8x5_UNORM = 132, + VK_FORMAT_ASTC_8x5_SRGB = 133, + VK_FORMAT_ASTC_8x6_UNORM = 134, + VK_FORMAT_ASTC_8x6_SRGB = 135, + VK_FORMAT_ASTC_8x8_UNORM = 136, + VK_FORMAT_ASTC_8x8_SRGB = 137, + VK_FORMAT_ASTC_10x5_UNORM = 138, + VK_FORMAT_ASTC_10x5_SRGB = 139, + VK_FORMAT_ASTC_10x6_UNORM = 140, + VK_FORMAT_ASTC_10x6_SRGB = 141, + VK_FORMAT_ASTC_10x8_UNORM = 142, + VK_FORMAT_ASTC_10x8_SRGB = 143, + VK_FORMAT_ASTC_10x10_UNORM = 144, + VK_FORMAT_ASTC_10x10_SRGB = 145, + VK_FORMAT_ASTC_12x10_UNORM = 146, + VK_FORMAT_ASTC_12x10_SRGB = 147, + VK_FORMAT_ASTC_12x12_UNORM = 148, + VK_FORMAT_ASTC_12x12_SRGB = 149, + VK_FORMAT_B4G4R4A4_UNORM = 150, + VK_FORMAT_B5G5R5A1_UNORM = 151, + VK_FORMAT_B5G6R5_UNORM = 152, + VK_FORMAT_B5G6R5_USCALED = 153, + VK_FORMAT_B8G8R8_UNORM = 154, + VK_FORMAT_B8G8R8_SNORM = 155, + VK_FORMAT_B8G8R8_USCALED = 156, + VK_FORMAT_B8G8R8_SSCALED = 157, + VK_FORMAT_B8G8R8_UINT = 158, + VK_FORMAT_B8G8R8_SINT = 159, + VK_FORMAT_B8G8R8_SRGB = 160, + VK_FORMAT_B8G8R8A8_UNORM = 161, + VK_FORMAT_B8G8R8A8_SNORM = 162, + VK_FORMAT_B8G8R8A8_USCALED = 163, + VK_FORMAT_B8G8R8A8_SSCALED = 164, + VK_FORMAT_B8G8R8A8_UINT = 165, + VK_FORMAT_B8G8R8A8_SINT = 166, + VK_FORMAT_B8G8R8A8_SRGB = 167, + VK_FORMAT_B10G10R10A2_UNORM = 168, + VK_FORMAT_B10G10R10A2_SNORM = 169, + VK_FORMAT_B10G10R10A2_USCALED = 170, + VK_FORMAT_B10G10R10A2_SSCALED = 171, + VK_FORMAT_B10G10R10A2_UINT = 172, + VK_FORMAT_B10G10R10A2_SINT = 173, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, + VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum { + 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_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum { + VK_IMAGE_TILING_LINEAR = 0, + VK_IMAGE_TILING_OPTIMAL = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum { + 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_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum { + VK_IMAGE_ASPECT_COLOR = 0, + VK_IMAGE_ASPECT_DEPTH = 1, + VK_IMAGE_ASPECT_STENCIL = 2, + VK_IMAGE_ASPECT_METADATA = 3, + VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, + VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA, + VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1), + VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF +} VkImageAspect; + +typedef enum { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, + VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum { + 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_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum { + VK_BUFFER_VIEW_TYPE_RAW = 0, + VK_BUFFER_VIEW_TYPE_FORMATTED = 1, + VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW, + VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED, + VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1), + VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkBufferViewType; + +typedef enum { + 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_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum { + VK_CHANNEL_SWIZZLE_ZERO = 0, + VK_CHANNEL_SWIZZLE_ONE = 1, + VK_CHANNEL_SWIZZLE_R = 2, + VK_CHANNEL_SWIZZLE_G = 3, + VK_CHANNEL_SWIZZLE_B = 4, + VK_CHANNEL_SWIZZLE_A = 5, + VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, + VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, + VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), + VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkChannelSwizzle; + +typedef enum { + VK_SHADER_STAGE_VERTEX = 0, + VK_SHADER_STAGE_TESS_CONTROL = 1, + VK_SHADER_STAGE_TESS_EVALUATION = 2, + VK_SHADER_STAGE_GEOMETRY = 3, + VK_SHADER_STAGE_FRAGMENT = 4, + VK_SHADER_STAGE_COMPUTE = 5, + VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, + VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, + VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), + VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF +} VkShaderStage; + +typedef enum { + VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, + VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, + VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, + VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), + VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputStepRate; + +typedef enum { + 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_ADJ = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, + VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum { + VK_FILL_MODE_POINTS = 0, + VK_FILL_MODE_WIREFRAME = 1, + VK_FILL_MODE_SOLID = 2, + VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, + VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, + VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), + VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF +} VkFillMode; + +typedef enum { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT = 1, + VK_CULL_MODE_BACK = 2, + VK_CULL_MODE_FRONT_AND_BACK = 3, + VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, + VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, + VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), + VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF +} VkCullMode; + +typedef enum { + VK_FRONT_FACE_CCW = 0, + VK_FRONT_FACE_CW = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, + VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_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_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INC_CLAMP = 3, + VK_STENCIL_OP_DEC_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INC_WRAP = 6, + VK_STENCIL_OP_DEC_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, + VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum { + 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_NOOP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIV = 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_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum { + VK_BLEND_ZERO = 0, + VK_BLEND_ONE = 1, + VK_BLEND_SRC_COLOR = 2, + VK_BLEND_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_DEST_COLOR = 4, + VK_BLEND_ONE_MINUS_DEST_COLOR = 5, + VK_BLEND_SRC_ALPHA = 6, + VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_DEST_ALPHA = 8, + VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, + VK_BLEND_CONSTANT_COLOR = 10, + VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_CONSTANT_ALPHA = 12, + VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_SRC_ALPHA_SATURATE = 14, + VK_BLEND_SRC1_COLOR = 15, + VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_SRC1_ALPHA = 17, + VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, + VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), + VK_BLEND_MAX_ENUM = 0x7FFFFFFF +} VkBlend; + +typedef enum { + 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_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum { + VK_TEX_FILTER_NEAREST = 0, + VK_TEX_FILTER_LINEAR = 1, + VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, + VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, + VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), + VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkTexFilter; + +typedef enum { + VK_TEX_MIPMAP_MODE_BASE = 0, + VK_TEX_MIPMAP_MODE_NEAREST = 1, + VK_TEX_MIPMAP_MODE_LINEAR = 2, + VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, + VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, + VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), + VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkTexMipmapMode; + +typedef enum { + VK_TEX_ADDRESS_WRAP = 0, + VK_TEX_ADDRESS_MIRROR = 1, + VK_TEX_ADDRESS_CLAMP = 2, + VK_TEX_ADDRESS_MIRROR_ONCE = 3, + VK_TEX_ADDRESS_CLAMP_BORDER = 4, + VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, + VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, + VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1), + VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF +} VkTexAddress; + +typedef enum { + 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_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum { + 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_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum { + VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, + VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, + VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, + VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, + VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), + VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolUsage; + +typedef enum { + VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, + VK_DESCRIPTOR_SET_USAGE_STATIC = 1, + VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, + VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, + VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), + VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetUsage; + +typedef enum { + 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_SOURCE_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, + VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum { + 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_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum { + 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_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum { + VK_PIPELINE_BIND_POINT_COMPUTE = 0, + VK_PIPELINE_BIND_POINT_GRAPHICS = 1, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum { + VK_CMD_BUFFER_LEVEL_PRIMARY = 0, + VK_CMD_BUFFER_LEVEL_SECONDARY = 1, + VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, + VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, + VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), + VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCmdBufferLevel; + +typedef enum { + 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_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum { + VK_TIMESTAMP_TYPE_TOP = 0, + VK_TIMESTAMP_TYPE_BOTTOM = 1, + VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, + VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, + VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), + VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkTimestampType; + +typedef enum { + VK_RENDER_PASS_CONTENTS_INLINE = 0, + VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, + VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, + VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, + VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), + VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkRenderPassContents; + + +typedef enum { + 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_CONVERSION_BIT = 0x00000400, +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum { + VK_IMAGE_USAGE_GENERAL = 0, + VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DESTINATION_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_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_DMA_BIT = 0x00000004, + VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, + VK_QUEUE_EXTENDED_BIT = 0x40000000, +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum { + VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum { + VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; + +typedef enum { + VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, +} VkDeviceCreateFlagBits; +typedef VkFlags VkDeviceCreateFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum { + VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum { + VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; + +typedef enum { + VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum { + VK_QUERY_RESULT_DEFAULT = 0, + 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, +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum { + VK_BUFFER_USAGE_GENERAL = 0, + VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DESTINATION_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, +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; + +typedef enum { + VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum { + VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum { + VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, + VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, +} VkAttachmentViewCreateFlagBits; +typedef VkFlags VkAttachmentViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkShaderCreateFlags; + +typedef enum { + VK_CHANNEL_R_BIT = 0x00000001, + VK_CHANNEL_G_BIT = 0x00000002, + VK_CHANNEL_B_BIT = 0x00000004, + VK_CHANNEL_A_BIT = 0x00000008, +} VkChannelFlagBits; +typedef VkFlags VkChannelFlags; + +typedef enum { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; + +typedef enum { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESS_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 = 0x7FFFFFFF, +} VkShaderStageFlagBits; +typedef VkFlags VkShaderStageFlags; + +typedef enum { + VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum { + 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_TESS_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESS_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_TRANSITION_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, + VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF, +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; + +typedef enum { + VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, + VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, + VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, + VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, + VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, +} VkMemoryOutputFlagBits; +typedef VkFlags VkMemoryOutputFlags; + +typedef enum { + VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, + VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, + VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, + VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, + VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, + VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, + VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, + VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, + VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, + VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, +} VkMemoryInputFlagBits; +typedef VkFlags VkMemoryInputFlags; + +typedef enum { + VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, +} VkCmdPoolCreateFlagBits; +typedef VkFlags VkCmdPoolCreateFlags; + +typedef enum { + VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001, +} VkCmdPoolResetFlagBits; +typedef VkFlags VkCmdPoolResetFlags; +typedef VkFlags VkCmdBufferCreateFlags; + +typedef enum { + VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, + VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, + VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, + VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, + VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, +} VkCmdBufferOptimizeFlagBits; +typedef VkFlags VkCmdBufferOptimizeFlags; + +typedef enum { + VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001, +} VkCmdBufferResetFlagBits; +typedef VkFlags VkCmdBufferResetFlags; + +typedef enum { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum { + VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef struct { + VkStructureType sType; + const void* pNext; + const char* pAppName; + uint32_t appVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef void* (VKAPI *PFN_vkAllocFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocType allocType); + +typedef void (VKAPI *PFN_vkFreeFunction)( + void* pUserData, + void* pMem); + +typedef struct { + void* pUserData; + PFN_vkAllocFunction pfnAlloc; + PFN_vkFreeFunction pfnFree; +} VkAllocCallbacks; + +typedef struct { + VkStructureType sType; + const void* pNext; + const VkApplicationInfo* pAppInfo; + const VkAllocCallbacks* pAllocCb; + uint32_t layerCount; + const char*const* ppEnabledLayerNames; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSourceBlend; + VkBool32 logicOp; + VkBool32 instancedDrawIndirect; + VkBool32 depthClip; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexSideEffects; + VkBool32 tessellationSideEffects; + VkBool32 geometrySideEffects; + VkBool32 fragmentSideEffects; + VkBool32 shaderTessellationPointSize; + VkBool32 shaderGeometryPointSize; + VkBool32 shaderTextureGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageBufferArrayConstantIndexing; + VkBool32 shaderStorageImageArrayConstantIndexing; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderFloat16; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLOD; + VkBool32 sparse; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyStandard2DBlockShape; + VkBool32 sparseResidencyStandard2DMSBlockShape; + VkBool32 sparseResidencyStandard3DBlockShape; + VkBool32 sparseResidencyAlignedMipSize; + VkBool32 sparseResidencyNonResident; + VkBool32 sparseResidencyNonResidentStrict; + VkBool32 sparseResidencyAliased; +} VkPhysicalDeviceFeatures; + +typedef struct { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; +} VkFormatProperties; + +typedef struct { + uint64_t maxResourceSize; + uint32_t maxSamples; +} VkImageFormatProperties; + +typedef struct { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferSize; + uint32_t maxUniformBufferSize; + uint32_t maxStorageBufferSize; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + VkDeviceSize bufferImageGranularity; + uint32_t maxBoundDescriptorSets; + uint32_t maxDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessGenLevel; + uint32_t maxTessPatchSize; + uint32_t maxTessControlPerVertexInputComponents; + uint32_t maxTessControlPerVertexOutputComponents; + uint32_t maxTessControlPerPatchOutputComponents; + uint32_t maxTessControlTotalOutputComponents; + uint32_t maxTessEvaluationInputComponents; + uint32_t maxTessEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputBuffers; + uint32_t maxFragmentDualSourceBuffers; + 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 maxDrawIndirectInstanceCount; + VkBool32 primitiveRestartForPatches; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxDynamicViewportStates; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + uint32_t minMemoryMapAlignment; + uint32_t minTexelBufferOffsetAlignment; + uint32_t minUniformBufferOffsetAlignment; + uint32_t minStorageBufferOffsetAlignment; + uint32_t minTexelOffset; + uint32_t maxTexelOffset; + uint32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + uint32_t maxFramebufferColorSamples; + uint32_t maxFramebufferDepthSamples; + uint32_t maxFramebufferStencilSamples; + uint32_t maxColorAttachments; + uint32_t maxSampledImageColorSamples; + uint32_t maxSampledImageDepthSamples; + uint32_t maxSampledImageIntegerSamples; + uint32_t maxStorageImageSamples; + uint32_t maxSampleMaskWords; + uint64_t timestampFrequency; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; +} VkPhysicalDeviceLimits; + +typedef struct { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorId; + uint32_t deviceId; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; + uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; +} VkPhysicalDeviceProperties; + +typedef struct { + VkQueueFlags queueFlags; + uint32_t queueCount; + VkBool32 supportsTimestamps; +} VkPhysicalDeviceQueueProperties; + +typedef struct { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef void (VKAPI *PFN_vkVoidFunction)(void); +typedef struct { + uint32_t queueFamilyIndex; + uint32_t queueCount; +} VkDeviceQueueCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueRecordCount; + const VkDeviceQueueCreateInfo* pRequestedQueues; + uint32_t layerCount; + const char*const* ppEnabledLayerNames; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; + VkDeviceCreateFlags flags; +} VkDeviceCreateInfo; + +typedef struct { + char extName[VK_MAX_EXTENSION_NAME]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct { + char layerName[VK_MAX_EXTENSION_NAME]; + uint32_t specVersion; + uint32_t implVersion; + char description[VK_MAX_DESCRIPTION]; +} VkLayerProperties; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceMemory mem; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct { + int32_t width; + int32_t height; + int32_t depth; +} VkExtent3D; + +typedef struct { + VkImageAspect aspect; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct { + VkSparseImageFormatProperties formatProps; + uint32_t imageMipTailStartLOD; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct { + VkDeviceSize rangeOffset; + VkDeviceSize rangeSize; + VkDeviceSize memOffset; + VkDeviceMemory mem; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBindInfo; + +typedef struct { + VkImageAspect aspect; + uint32_t mipLevel; + uint32_t arraySlice; +} VkImageSubresource; + +typedef struct { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceSize memOffset; + VkDeviceMemory mem; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBindInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkQueryType queryType; + uint32_t slots; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkBufferCreateFlags flags; + VkSharingMode sharingMode; + uint32_t queueFamilyCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkBufferViewType viewType; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arraySize; + uint32_t samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + VkSharingMode sharingMode; + uint32_t queueFamilyCount; + const uint32_t* pQueueFamilyIndices; +} VkImageCreateInfo; + +typedef struct { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct { + VkChannelSwizzle r; + VkChannelSwizzle g; + VkChannelSwizzle b; + VkChannelSwizzle a; +} VkChannelMapping; + +typedef struct { + VkImageAspect aspect; + uint32_t baseMipLevel; + uint32_t mipLevels; + uint32_t baseArraySlice; + uint32_t arraySize; +} VkImageSubresourceRange; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkChannelMapping channels; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImage image; + VkFormat format; + uint32_t mipLevel; + uint32_t baseArraySlice; + uint32_t arraySize; + VkAttachmentViewCreateFlags flags; +} VkAttachmentViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + size_t codeSize; + const void* pCode; + VkShaderModuleCreateFlags flags; +} VkShaderModuleCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkShaderModule module; + const char* pName; + VkShaderCreateFlags flags; +} VkShaderCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + size_t initialSize; + const void* initialData; + size_t maxSize; +} VkPipelineCacheCreateInfo; + +typedef struct { + uint32_t constantId; + size_t size; + uint32_t offset; +} VkSpecializationMapEntry; + +typedef struct { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMap; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkShaderStage stage; + VkShader shader; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct { + uint32_t binding; + uint32_t strideInBytes; + VkVertexInputStepRate stepRate; +} VkVertexInputBindingDescription; + +typedef struct { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offsetInBytes; +} VkVertexInputAttributeDescription; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t attributeCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t viewportCount; +} VkPipelineViewportStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 depthClipEnable; + VkBool32 rasterizerDiscardEnable; + VkFillMode fillMode; + VkCullMode cullMode; + VkFrontFace frontFace; +} VkPipelineRasterStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t rasterSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask sampleMask; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct { + VkStencilOp stencilFailOp; + VkStencilOp stencilPassOp; + VkStencilOp stencilDepthFailOp; + VkCompareOp stencilCompareOp; +} VkStencilOpState; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct { + VkBool32 blendEnable; + VkBlend srcBlendColor; + VkBlend destBlendColor; + VkBlendOp blendOpColor; + VkBlend srcBlendAlpha; + VkBlend destBlendAlpha; + VkBlendOp blendOpAlpha; + VkChannelFlags channelWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 alphaToCoverageEnable; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterStateCreateInfo* pRasterState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + VkPipelineCreateFlags flags; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateInfo cs; + VkPipelineCreateFlags flags; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct { + VkShaderStageFlags stageFlags; + uint32_t start; + uint32_t length; +} VkPushConstantRange; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkTexFilter magFilter; + VkTexFilter minFilter; + VkTexMipmapMode mipMode; + VkTexAddress addressU; + VkTexAddress addressV; + VkTexAddress addressW; + float mipLodBias; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; +} VkSamplerCreateInfo; + +typedef struct { + VkDescriptorType descriptorType; + uint32_t arraySize; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t count; + const VkDescriptorSetLayoutBinding* pBinding; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct { + VkDescriptorType type; + uint32_t count; +} VkDescriptorTypeCount; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t count; + const VkDescriptorTypeCount* pTypeCount; +} VkDescriptorPoolCreateInfo; + +typedef struct { + VkBufferView bufferView; + VkSampler sampler; + VkImageView imageView; + VkAttachmentView attachmentView; + VkImageLayout imageLayout; +} VkDescriptorInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorSet destSet; + uint32_t destBinding; + uint32_t destArrayElement; + uint32_t count; + VkDescriptorType descriptorType; + const VkDescriptorInfo* pDescriptors; +} VkWriteDescriptorSet; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet destSet; + uint32_t destBinding; + uint32_t destArrayElement; + uint32_t count; +} VkCopyDescriptorSet; + +typedef struct { + float originX; + float originY; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct { + int32_t width; + int32_t height; +} VkExtent2D; + +typedef struct { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t viewportAndScissorCount; + const VkViewport* pViewports; + const VkRect2D* pScissors; +} VkDynamicViewportStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + float depthBias; + float depthBiasClamp; + float slopeScaledDepthBias; + float lineWidth; +} VkDynamicRasterStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + float blendConst[4]; +} VkDynamicColorBlendStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + float minDepthBounds; + float maxDepthBounds; + uint32_t stencilReadMask; + uint32_t stencilWriteMask; + uint32_t stencilFrontRef; + uint32_t stencilBackRef; +} VkDynamicDepthStencilStateCreateInfo; + +typedef struct { + VkAttachmentView view; + VkImageLayout layout; +} VkAttachmentBindInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkAttachmentBindInfo* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkFormat format; + uint32_t samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkSubpassDescriptionFlags flags; + uint32_t inputCount; + const VkAttachmentReference* inputAttachments; + uint32_t colorCount; + const VkAttachmentReference* colorAttachments; + const VkAttachmentReference* resolveAttachments; + VkAttachmentReference depthStencilAttachment; + uint32_t preserveCount; + const VkAttachmentReference* preserveAttachments; +} VkSubpassDescription; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t destSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags destStageMask; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + VkBool32 byRegion; +} VkSubpassDependency; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkCmdPoolCreateFlags flags; +} VkCmdPoolCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkCmdPool cmdPool; + VkCmdBufferLevel level; + VkCmdBufferCreateFlags flags; +} VkCmdBufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkCmdBufferOptimizeFlags flags; + VkRenderPass renderPass; + VkFramebuffer framebuffer; +} VkCmdBufferBeginInfo; + +typedef struct { + VkDeviceSize srcOffset; + VkDeviceSize destOffset; + VkDeviceSize copySize; +} VkBufferCopy; + +typedef struct { + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct { + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkExtent3D srcExtent; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D destExtent; +} VkImageBlit; + +typedef struct { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresource imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union { + float f32[4]; + int32_t s32[4]; + uint32_t u32[4]; +} VkClearColorValue; + +typedef struct { + VkOffset3D offset; + VkExtent3D extent; +} VkRect3D; + +typedef struct { + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union { + VkClearColorValue color; + VkClearDepthStencilValue ds; +} VkClearValue; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t attachmentCount; + const VkClearValue* pAttachmentClearValues; +} VkRenderPassBeginInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + uint32_t srcQueueFamilyIndex; + uint32_t destQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCmd; + +typedef struct { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCmd; + +typedef struct { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCmd; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t destQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; +} VkMemoryBarrier; + + +typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); +typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); +typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); +typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); +typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); +typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); +typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); +typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); +typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); +typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); +typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); +typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); +typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); +typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); +typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); +typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); +typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); +typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); +typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); +typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); +typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); +typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView); +typedef VkResult (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView); +typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); +typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); +typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); +typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); +typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); +typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); +typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); +typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); +typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); +typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); +typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); +typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); +typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); +typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); +typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); +typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); +typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); +typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); +typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); +typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); +typedef VkResult (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); +typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); +typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); +typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); +typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); +typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); +typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); +typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState); +typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState); +typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); +typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); +typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); +typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); +typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); +typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); +typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); +typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); +typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); +typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); +typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents); +typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); +typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); + +#ifdef VK_PROTOTYPES +VkResult VKAPI vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + VkInstance* pInstance); + +VkResult VKAPI vkDestroyInstance( + VkInstance instance); + +VkResult VKAPI vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VkResult VKAPI vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VkResult VKAPI vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageFormatProperties* pImageFormatProperties); + +VkResult VKAPI vkGetPhysicalDeviceLimits( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceLimits* pLimits); + +VkResult VKAPI vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceQueueCount( + VkPhysicalDevice physicalDevice, + uint32_t* pCount); + +VkResult VKAPI vkGetPhysicalDeviceQueueProperties( + VkPhysicalDevice physicalDevice, + uint32_t count, + VkPhysicalDeviceQueueProperties* pQueueProperties); + +VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VkResult VKAPI vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice); + +VkResult VKAPI vkDestroyDevice( + VkDevice device); + +VkResult VKAPI vkGetGlobalExtensionProperties( + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult VKAPI vkGetGlobalLayerProperties( + uint32_t* pCount, + VkLayerProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pCount, + VkLayerProperties* pProperties); + +VkResult VKAPI vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VkResult VKAPI vkQueueSubmit( + VkQueue queue, + uint32_t cmdBufferCount, + const VkCmdBuffer* pCmdBuffers, + VkFence fence); + +VkResult VKAPI vkQueueWaitIdle( + VkQueue queue); + +VkResult VKAPI vkDeviceWaitIdle( + VkDevice device); + +VkResult VKAPI vkAllocMemory( + VkDevice device, + const VkMemoryAllocInfo* pAllocInfo, + VkDeviceMemory* pMem); + +VkResult VKAPI vkFreeMemory( + VkDevice device, + VkDeviceMemory mem); + +VkResult VKAPI vkMapMemory( + VkDevice device, + VkDeviceMemory mem, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VkResult VKAPI vkUnmapMemory( + VkDevice device, + VkDeviceMemory mem); + +VkResult VKAPI vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges); + +VkResult VKAPI vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges); + +VkResult VKAPI vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VkResult VKAPI vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory mem, + VkDeviceSize memOffset); + +VkResult VKAPI vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory mem, + VkDeviceSize memOffset); + +VkResult VKAPI vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VkResult VKAPI vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VkResult VKAPI vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pNumRequirements, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + uint32_t samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pNumProperties, + VkSparseImageFormatProperties* pProperties); + +VkResult VKAPI vkQueueBindSparseBufferMemory( + VkQueue queue, + VkBuffer buffer, + uint32_t numBindings, + const VkSparseMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkQueueBindSparseImageOpaqueMemory( + VkQueue queue, + VkImage image, + uint32_t numBindings, + const VkSparseMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkQueueBindSparseImageMemory( + VkQueue queue, + VkImage image, + uint32_t numBindings, + const VkSparseImageMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence); + +VkResult VKAPI vkDestroyFence( + VkDevice device, + VkFence fence); + +VkResult VKAPI vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VkResult VKAPI vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VkResult VKAPI vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VkResult VKAPI vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + VkSemaphore* pSemaphore); + +VkResult VKAPI vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore); + +VkResult VKAPI vkQueueSignalSemaphore( + VkQueue queue, + VkSemaphore semaphore); + +VkResult VKAPI vkQueueWaitSemaphore( + VkQueue queue, + VkSemaphore semaphore); + +VkResult VKAPI vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + VkEvent* pEvent); + +VkResult VKAPI vkDestroyEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkGetEventStatus( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkSetEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkResetEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool); + +VkResult VKAPI vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool); + +VkResult VKAPI vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + size_t* pDataSize, + void* pData, + VkQueryResultFlags flags); + +VkResult VKAPI vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + VkBuffer* pBuffer); + +VkResult VKAPI vkDestroyBuffer( + VkDevice device, + VkBuffer buffer); + +VkResult VKAPI vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + VkBufferView* pView); + +VkResult VKAPI vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView); + +VkResult VKAPI vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + VkImage* pImage); + +VkResult VKAPI vkDestroyImage( + VkDevice device, + VkImage image); + +VkResult VKAPI vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VkResult VKAPI vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + VkImageView* pView); + +VkResult VKAPI vkDestroyImageView( + VkDevice device, + VkImageView imageView); + +VkResult VKAPI vkCreateAttachmentView( + VkDevice device, + const VkAttachmentViewCreateInfo* pCreateInfo, + VkAttachmentView* pView); + +VkResult VKAPI vkDestroyAttachmentView( + VkDevice device, + VkAttachmentView attachmentView); + +VkResult VKAPI vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModule* pShaderModule); + +VkResult VKAPI vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule); + +VkResult VKAPI vkCreateShader( + VkDevice device, + const VkShaderCreateInfo* pCreateInfo, + VkShader* pShader); + +VkResult VKAPI vkDestroyShader( + VkDevice device, + VkShader shader); + +VkResult VKAPI vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + VkPipelineCache* pPipelineCache); + +VkResult VKAPI vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache); + +size_t VKAPI vkGetPipelineCacheSize( + VkDevice device, + VkPipelineCache pipelineCache); + +VkResult VKAPI vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + void* pData); + +VkResult VKAPI vkMergePipelineCaches( + VkDevice device, + VkPipelineCache destCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VkResult VKAPI vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +VkResult VKAPI vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkComputePipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +VkResult VKAPI vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline); + +VkResult VKAPI vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + VkPipelineLayout* pPipelineLayout); + +VkResult VKAPI vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout); + +VkResult VKAPI vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + VkSampler* pSampler); + +VkResult VKAPI vkDestroySampler( + VkDevice device, + VkSampler sampler); + +VkResult VKAPI vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayout* pSetLayout); + +VkResult VKAPI vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout); + +VkResult VKAPI vkCreateDescriptorPool( + VkDevice device, + VkDescriptorPoolUsage poolUsage, + uint32_t maxSets, + const VkDescriptorPoolCreateInfo* pCreateInfo, + VkDescriptorPool* pDescriptorPool); + +VkResult VKAPI vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool); + +VkResult VKAPI vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool); + +VkResult VKAPI vkAllocDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorSetUsage setUsage, + uint32_t count, + const VkDescriptorSetLayout* pSetLayouts, + VkDescriptorSet* pDescriptorSets, + uint32_t* pCount); + +VkResult VKAPI vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t count, + const VkDescriptorSet* pDescriptorSets); + +VkResult VKAPI vkUpdateDescriptorSets( + VkDevice device, + uint32_t writeCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t copyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VkResult VKAPI vkCreateDynamicViewportState( + VkDevice device, + const VkDynamicViewportStateCreateInfo* pCreateInfo, + VkDynamicViewportState* pState); + +VkResult VKAPI vkDestroyDynamicViewportState( + VkDevice device, + VkDynamicViewportState dynamicViewportState); + +VkResult VKAPI vkCreateDynamicRasterState( + VkDevice device, + const VkDynamicRasterStateCreateInfo* pCreateInfo, + VkDynamicRasterState* pState); + +VkResult VKAPI vkDestroyDynamicRasterState( + VkDevice device, + VkDynamicRasterState dynamicRasterState); + +VkResult VKAPI vkCreateDynamicColorBlendState( + VkDevice device, + const VkDynamicColorBlendStateCreateInfo* pCreateInfo, + VkDynamicColorBlendState* pState); + +VkResult VKAPI vkDestroyDynamicColorBlendState( + VkDevice device, + VkDynamicColorBlendState dynamicColorBlendState); + +VkResult VKAPI vkCreateDynamicDepthStencilState( + VkDevice device, + const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, + VkDynamicDepthStencilState* pState); + +VkResult VKAPI vkDestroyDynamicDepthStencilState( + VkDevice device, + VkDynamicDepthStencilState dynamicDepthStencilState); + +VkResult VKAPI vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + VkFramebuffer* pFramebuffer); + +VkResult VKAPI vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer); + +VkResult VKAPI vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + VkRenderPass* pRenderPass); + +VkResult VKAPI vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass); + +VkResult VKAPI vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VkResult VKAPI vkCreateCommandPool( + VkDevice device, + const VkCmdPoolCreateInfo* pCreateInfo, + VkCmdPool* pCmdPool); + +VkResult VKAPI vkDestroyCommandPool( + VkDevice device, + VkCmdPool cmdPool); + +VkResult VKAPI vkResetCommandPool( + VkDevice device, + VkCmdPool cmdPool, + VkCmdPoolResetFlags flags); + +VkResult VKAPI vkCreateCommandBuffer( + VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer); + +VkResult VKAPI vkDestroyCommandBuffer( + VkDevice device, + VkCmdBuffer commandBuffer); + +VkResult VKAPI vkBeginCommandBuffer( + VkCmdBuffer cmdBuffer, + const VkCmdBufferBeginInfo* pBeginInfo); + +VkResult VKAPI vkEndCommandBuffer( + VkCmdBuffer cmdBuffer); + +VkResult VKAPI vkResetCommandBuffer( + VkCmdBuffer cmdBuffer, + VkCmdBufferResetFlags flags); + +void VKAPI vkCmdBindPipeline( + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +void VKAPI vkCmdBindDynamicViewportState( + VkCmdBuffer cmdBuffer, + VkDynamicViewportState dynamicViewportState); + +void VKAPI vkCmdBindDynamicRasterState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterState dynamicRasterState); + +void VKAPI vkCmdBindDynamicColorBlendState( + VkCmdBuffer cmdBuffer, + VkDynamicColorBlendState dynamicColorBlendState); + +void VKAPI vkCmdBindDynamicDepthStencilState( + VkCmdBuffer cmdBuffer, + VkDynamicDepthStencilState dynamicDepthStencilState); + +void VKAPI vkCmdBindDescriptorSets( + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +void VKAPI vkCmdBindIndexBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +void VKAPI vkCmdBindVertexBuffers( + VkCmdBuffer cmdBuffer, + uint32_t startBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +void VKAPI vkCmdDraw( + VkCmdBuffer cmdBuffer, + uint32_t firstVertex, + uint32_t vertexCount, + uint32_t firstInstance, + uint32_t instanceCount); + +void VKAPI vkCmdDrawIndexed( + VkCmdBuffer cmdBuffer, + uint32_t firstIndex, + uint32_t indexCount, + int32_t vertexOffset, + uint32_t firstInstance, + uint32_t instanceCount); + +void VKAPI vkCmdDrawIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t count, + uint32_t stride); + +void VKAPI vkCmdDrawIndexedIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t count, + uint32_t stride); + +void VKAPI vkCmdDispatch( + VkCmdBuffer cmdBuffer, + uint32_t x, + uint32_t y, + uint32_t z); + +void VKAPI vkCmdDispatchIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +void VKAPI vkCmdCopyBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkBuffer destBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +void VKAPI vkCmdCopyImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +void VKAPI vkCmdBlitImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkTexFilter filter); + +void VKAPI vkCmdCopyBufferToImage( + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +void VKAPI vkCmdCopyImageToBuffer( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +void VKAPI vkCmdUpdateBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize dataSize, + const uint32_t* pData); + +void VKAPI vkCmdFillBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize fillSize, + uint32_t data); + +void VKAPI vkCmdClearColorImage( + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +void VKAPI vkCmdClearDepthStencilImage( + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + float depth, + uint32_t stencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +void VKAPI vkCmdClearColorAttachment( + VkCmdBuffer cmdBuffer, + uint32_t colorAttachment, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rectCount, + const VkRect3D* pRects); + +void VKAPI vkCmdClearDepthStencilAttachment( + VkCmdBuffer cmdBuffer, + VkImageAspectFlags imageAspectMask, + VkImageLayout imageLayout, + float depth, + uint32_t stencil, + uint32_t rectCount, + const VkRect3D* pRects); + +void VKAPI vkCmdResolveImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +void VKAPI vkCmdSetEvent( + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +void VKAPI vkCmdResetEvent( + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +void VKAPI vkCmdWaitEvents( + VkCmdBuffer cmdBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + uint32_t memBarrierCount, + const void* const* ppMemBarriers); + +void VKAPI vkCmdPipelineBarrier( + VkCmdBuffer cmdBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + VkBool32 byRegion, + uint32_t memBarrierCount, + const void* const* ppMemBarriers); + +void VKAPI vkCmdBeginQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot, + VkQueryControlFlags flags); + +void VKAPI vkCmdEndQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot); + +void VKAPI vkCmdResetQueryPool( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount); + +void VKAPI vkCmdWriteTimestamp( + VkCmdBuffer cmdBuffer, + VkTimestampType timestampType, + VkBuffer destBuffer, + VkDeviceSize destOffset); + +void VKAPI vkCmdCopyQueryPoolResults( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize destStride, + VkQueryResultFlags flags); + +void VKAPI vkCmdPushConstants( + VkCmdBuffer cmdBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t start, + uint32_t length, + const void* values); + +void VKAPI vkCmdBeginRenderPass( + VkCmdBuffer cmdBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkRenderPassContents contents); + +void VKAPI vkCmdNextSubpass( + VkCmdBuffer cmdBuffer, + VkRenderPassContents contents); + +void VKAPI vkCmdEndRenderPass( + VkCmdBuffer cmdBuffer); + +void VKAPI vkCmdExecuteCommands( + VkCmdBuffer cmdBuffer, + uint32_t cmdBuffersCount, + const VkCmdBuffer* pCmdBuffers); +#endif + +#ifdef __cplusplus +} +#endif + +#endif From 3694518be5817b411263c049befb85f0e882911d Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Sun, 4 Oct 2015 09:14:57 -0700 Subject: [PATCH 03/76] vk/0.170.2: Drop VkBufferViewCreateInfo::viewType --- include/vulkan/vulkan.h | 1 - 1 file changed, 1 deletion(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 9877233bfeb..6b8ca6022ee 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1469,7 +1469,6 @@ typedef struct { VkStructureType sType; const void* pNext; VkBuffer buffer; - VkBufferViewType viewType; VkFormat format; VkDeviceSize offset; VkDeviceSize range; From 8cb2e27c62ab958f028eb2887b84a17e95ffe8ec Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Sun, 4 Oct 2015 09:26:25 -0700 Subject: [PATCH 04/76] vk/0.170.2: Update VkRenderPassBeginInfo Rename members: attachmentCount -> clearValueCount pAttachmentClearValues -> pClearValues --- include/vulkan/vulkan.h | 4 ++-- src/vulkan/anv_meta.c | 11 +++++++---- src/vulkan/gen7_cmd_buffer.c | 2 +- src/vulkan/gen8_cmd_buffer.c | 2 +- 4 files changed, 11 insertions(+), 8 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 6b8ca6022ee..16ed3f8dd67 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2020,8 +2020,8 @@ typedef struct { VkRenderPass renderPass; VkFramebuffer framebuffer; VkRect2D renderArea; - uint32_t attachmentCount; - const VkClearValue* pAttachmentClearValues; + uint32_t clearValueCount; + const VkClearValue* pClearValues; } VkRenderPassBeginInfo; typedef struct { diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index d7efdf69b62..11b8557805c 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -428,6 +428,9 @@ anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer, if (pass->has_stencil_clear_attachment) anv_finishme("stencil clear"); + /* FINISHME: Rethink how we count clear attachments in light of + * 0.138.2 -> 0.170.2 diff. + */ if (pass->num_color_clear_attachments == 0 && !pass->has_depth_clear_attachment) return; @@ -889,8 +892,8 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .offset = { dest_offset.x, dest_offset.y }, .extent = { dest_extent.width, dest_extent.height }, }, - .attachmentCount = 1, - .pAttachmentClearValues = NULL, + .clearValueCount = 0, + .pClearValues = NULL, }, VK_RENDER_PASS_CONTENTS_INLINE); VkPipeline pipeline; @@ -1621,8 +1624,8 @@ void anv_CmdClearColorImage( }, .renderPass = pass, .framebuffer = fb, - .attachmentCount = 1, - .pAttachmentClearValues = NULL, + .clearValueCount = 1, + .pClearValues = NULL, }, VK_RENDER_PASS_CONTENTS_INLINE); struct clear_instance_data instance_data = { diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index 95d1e28698f..323022b13f9 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -641,7 +641,7 @@ begin_render_pass(struct anv_cmd_buffer *cmd_buffer, .DrawingRectangleOriginX = 0); anv_cmd_buffer_clear_attachments(cmd_buffer, pass, - pRenderPassBegin->pAttachmentClearValues); + pRenderPassBegin->pClearValues); } void gen7_CmdBeginRenderPass( diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index 0e830b4427d..d82a409d886 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -580,7 +580,7 @@ void gen8_CmdBeginRenderPass( .DrawingRectangleOriginX = 0); anv_cmd_buffer_clear_attachments(cmd_buffer, pass, - pRenderPassBegin->pAttachmentClearValues); + pRenderPassBegin->pClearValues); gen8_cmd_buffer_begin_subpass(cmd_buffer, pass->subpasses); } From dd04be491d286dfc26ac8630ad3c9dbc839815cb Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Sun, 4 Oct 2015 09:41:22 -0700 Subject: [PATCH 05/76] vk/0.170.2: Update Vk VkPipelineDepthStencilStateCreateInfo Rename member depthBoundsEnable -> depthBoundsTestEnable. --- include/vulkan/vulkan.h | 2 +- src/vulkan/anv_meta.c | 2 +- src/vulkan/gen8_pipeline.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 16ed3f8dd67..1f35b01ae9b 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1652,7 +1652,7 @@ typedef struct { VkBool32 depthTestEnable; VkBool32 depthWriteEnable; VkCompareOp depthCompareOp; - VkBool32 depthBoundsEnable; + VkBool32 depthBoundsTestEnable; VkBool32 stencilTestEnable; VkStencilOpState front; VkStencilOpState back; diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 11b8557805c..e43d11b06ee 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -254,7 +254,7 @@ anv_device_init_meta_clear_state(struct anv_device *device) .depthTestEnable = true, .depthWriteEnable = true, .depthCompareOp = VK_COMPARE_OP_ALWAYS, - .depthBoundsEnable = false, + .depthBoundsTestEnable = false, .stencilTestEnable = true, .front = (VkStencilOpState) { .stencilPassOp = VK_STENCIL_OP_REPLACE, diff --git a/src/vulkan/gen8_pipeline.c b/src/vulkan/gen8_pipeline.c index fae09f3fbbe..4900715a47a 100644 --- a/src/vulkan/gen8_pipeline.c +++ b/src/vulkan/gen8_pipeline.c @@ -269,7 +269,7 @@ emit_ds_state(struct anv_pipeline *pipeline, return; } - /* VkBool32 depthBoundsEnable; // optional (depth_bounds_test) */ + /* VkBool32 depthBoundsTestEnable; // optional (depth_bounds_test) */ struct GEN8_3DSTATE_WM_DEPTH_STENCIL wm_depth_stencil = { .DepthTestEnable = info->depthTestEnable, From 6a40af1b08d42b460c4516c56b393c6e4f290fc2 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Sun, 4 Oct 2015 10:00:25 -0700 Subject: [PATCH 06/76] vk/0.170.2: Update VkPipelineMultisampleStateCreateInfo --- include/vulkan/vulkan.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 1f35b01ae9b..82c7916c469 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1636,7 +1636,7 @@ typedef struct { uint32_t rasterSamples; VkBool32 sampleShadingEnable; float minSampleShading; - VkSampleMask sampleMask; + const VkSampleMask* pSampleMask; } VkPipelineMultisampleStateCreateInfo; typedef struct { From 568654d6069923c6875ea72b3038408365d763a7 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 06:44:30 -0700 Subject: [PATCH 07/76] vk/0.170.2: Drop VK_IMAGE_USAGE_GENERAL --- include/vulkan/vulkan.h | 1 - 1 file changed, 1 deletion(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 82c7916c469..923a3b69ea3 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -853,7 +853,6 @@ typedef enum { typedef VkFlags VkFormatFeatureFlags; typedef enum { - VK_IMAGE_USAGE_GENERAL = 0, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, From 7a089bd1a60a38f4048cedc49f141b8917536ae3 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 06:48:14 -0700 Subject: [PATCH 08/76] vk/0.170.2: Update VkImageSubresourceRange Replace 'aspect' with 'aspectMask'. --- include/vulkan/vulkan.h | 2 +- src/vulkan/anv_image.c | 58 ++++++++++++++++++++++++---------------- src/vulkan/anv_meta.c | 10 +++---- src/vulkan/anv_private.h | 3 ++- src/vulkan/gen7_state.c | 2 +- src/vulkan/gen8_state.c | 2 +- 6 files changed, 45 insertions(+), 32 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 923a3b69ea3..fc6a1c638c6 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1505,7 +1505,7 @@ typedef struct { } VkChannelMapping; typedef struct { - VkImageAspect aspect; + VkImageAspectFlags aspectMask; uint32_t baseMipLevel; uint32_t mipLevels; uint32_t baseArraySlice; diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index dce4208ed5f..2045aa27219 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -415,8 +415,7 @@ anv_validate_CreateImageView(VkDevice _device, assert(pCreateInfo->channels.a <= VK_CHANNEL_SWIZZLE_END_RANGE); /* Validate subresource. */ - assert(subresource->aspect >= VK_IMAGE_ASPECT_BEGIN_RANGE); - assert(subresource->aspect <= VK_IMAGE_ASPECT_END_RANGE); + assert(subresource->aspectMask != 0); assert(subresource->mipLevels > 0); assert(subresource->arraySize > 0); assert(subresource->baseMipLevel < image->levels); @@ -430,28 +429,33 @@ anv_validate_CreateImageView(VkDevice _device, assert(subresource->arraySize % 6 == 0); } + const VkImageAspectFlags ds_flags = VK_IMAGE_ASPECT_DEPTH_BIT + | VK_IMAGE_ASPECT_STENCIL_BIT; + /* Validate format. */ - switch (subresource->aspect) { - case VK_IMAGE_ASPECT_COLOR: + if (subresource->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) { + assert(subresource->aspectMask == VK_IMAGE_ASPECT_COLOR_BIT); assert(!image->format->depth_format); assert(!image->format->has_stencil); assert(!view_format_info->depth_format); assert(!view_format_info->has_stencil); assert(view_format_info->cpp == image->format->cpp); - break; - case VK_IMAGE_ASPECT_DEPTH: - assert(image->format->depth_format); - assert(view_format_info->depth_format); - assert(view_format_info->cpp == image->format->cpp); - break; - case VK_IMAGE_ASPECT_STENCIL: - /* FINISHME: Is it legal to have an R8 view of S8? */ - assert(image->format->has_stencil); - assert(view_format_info->has_stencil); - break; - default: - assert(!"bad VkImageAspect"); - break; + } else if (subresource->aspectMask & ds_flags) { + assert((subresource->aspectMask & ~ds_flags) == 0); + + if (subresource->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) { + assert(image->format->depth_format); + assert(view_format_info->depth_format); + assert(view_format_info->cpp == image->format->cpp); + } + + if (subresource->aspectMask & VK_IMAGE_ASPECT_STENCIL) { + /* FINISHME: Is it legal to have an R8 view of S8? */ + assert(image->format->has_stencil); + assert(view_format_info->has_stencil); + } + } else { + assert(!"bad VkImageSubresourceRange::aspectFlags"); } return anv_CreateImageView(_device, pCreateInfo, pView); @@ -528,19 +532,27 @@ anv_depth_stencil_view_init(struct anv_depth_stencil_view *view, } struct anv_surface * -anv_image_get_surface_for_aspect(struct anv_image *image, VkImageAspect aspect) +anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlags aspect_mask) { - switch (aspect) { - case VK_IMAGE_ASPECT_COLOR: + switch (aspect_mask) { + case VK_IMAGE_ASPECT_COLOR_BIT: assert(anv_format_is_color(image->format)); return &image->color_surface; - case VK_IMAGE_ASPECT_DEPTH: + case VK_IMAGE_ASPECT_DEPTH_BIT: assert(image->format->depth_format); return &image->depth_surface; - case VK_IMAGE_ASPECT_STENCIL: + case VK_IMAGE_ASPECT_STENCIL_BIT: assert(image->format->has_stencil); anv_finishme("stencil image views"); return &image->stencil_surface; + case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT: + /* FINISHME: Support combined depthstencil aspect. Does the Vulkan spec + * allow is to reject it? Until we support it, filter out the stencil + * aspect and use only the depth aspect. + */ + anv_finishme("combined depthstencil aspect"); + assert(image->format->depth_format); + return &image->depth_surface; default: unreachable("image does not have aspect"); return NULL; diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index e43d11b06ee..dd8f3a958a6 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -1013,7 +1013,7 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, VK_CHANNEL_SWIZZLE_A }, .subresourceRange = { - .aspect = VK_IMAGE_ASPECT_COLOR, + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0, .mipLevels = 1, .baseArraySlice = 0, @@ -1161,7 +1161,7 @@ void anv_CmdCopyImage( VK_CHANNEL_SWIZZLE_A }, .subresourceRange = { - .aspect = pRegions[r].srcSubresource.aspect, + .aspectMask = 1 << pRegions[r].srcSubresource.aspect, .baseMipLevel = pRegions[r].srcSubresource.mipLevel, .mipLevels = 1, .baseArraySlice = pRegions[r].srcSubresource.arraySlice, @@ -1247,7 +1247,7 @@ void anv_CmdBlitImage( VK_CHANNEL_SWIZZLE_A }, .subresourceRange = { - .aspect = pRegions[r].srcSubresource.aspect, + .aspectMask = 1 << pRegions[r].srcSubresource.aspect, .baseMipLevel = pRegions[r].srcSubresource.mipLevel, .mipLevels = 1, .baseArraySlice = pRegions[r].srcSubresource.arraySlice, @@ -1377,7 +1377,7 @@ void anv_CmdCopyBufferToImage( VK_CHANNEL_SWIZZLE_A }, .subresourceRange = { - .aspect = proxy_aspect, + .aspectMask = 1 << proxy_aspect, .baseMipLevel = 0, .mipLevels = 1, .baseArraySlice = 0, @@ -1464,7 +1464,7 @@ void anv_CmdCopyImageToBuffer( VK_CHANNEL_SWIZZLE_A }, .subresourceRange = { - .aspect = pRegions[r].imageSubresource.aspect, + .aspectMask = 1 << pRegions[r].imageSubresource.aspect, .baseMipLevel = pRegions[r].imageSubresource.mipLevel, .mipLevels = 1, .baseArraySlice = pRegions[r].imageSubresource.arraySlice, diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index f0d288342d6..a2211bb76b3 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1273,7 +1273,8 @@ VkResult anv_image_create(VkDevice _device, VkImage *pImage); struct anv_surface * -anv_image_get_surface_for_aspect(struct anv_image *image, VkImageAspect aspect); +anv_image_get_surface_for_aspect_mask(struct anv_image *image, + VkImageAspectFlags aspect_mask); struct anv_surface * anv_image_get_surface_for_color_attachment(struct anv_image *image); diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index faf99a5aef8..f93349da0b0 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -274,7 +274,7 @@ gen7_image_view_init(struct anv_image_view *iview, const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; struct anv_surface_view *view = &iview->view; struct anv_surface *surface = - anv_image_get_surface_for_aspect(image, range->aspect); + anv_image_get_surface_for_aspect_mask(image, range->aspectMask); const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 5646637e4a0..3709a50005d 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -150,7 +150,7 @@ gen8_image_view_init(struct anv_image_view *iview, const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; struct anv_surface_view *view = &iview->view; struct anv_surface *surface = - anv_image_get_surface_for_aspect(image, range->aspect); + anv_image_get_surface_for_aspect_mask(image, range->aspectMask); uint32_t depth = 1; /* RENDER_SURFACE_STATE::Depth */ uint32_t rt_view_extent = 1; /* RENDER_SURFACE_STATE::RenderTargetViewExtent */ From 4744f60e79b9a9beeb174c212a557c9d868ab2db Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 07:17:07 -0700 Subject: [PATCH 09/76] vk/0.170.2: Drop enum VkBufferViewType --- include/vulkan/vulkan.h | 9 --------- 1 file changed, 9 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index fc6a1c638c6..45a331a0679 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -480,15 +480,6 @@ typedef enum { VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF } VkSharingMode; -typedef enum { - VK_BUFFER_VIEW_TYPE_RAW = 0, - VK_BUFFER_VIEW_TYPE_FORMATTED = 1, - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW, - VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED, - VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1), - VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkBufferViewType; - typedef enum { VK_IMAGE_VIEW_TYPE_1D = 0, VK_IMAGE_VIEW_TYPE_2D = 1, From 6317c3144dc9078098f4d380759a50021798e14c Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 07:18:46 -0700 Subject: [PATCH 10/76] vk/0.170.2: Drop VK_BUFFER_USAGE_GENERAL --- include/vulkan/vulkan.h | 1 - 1 file changed, 1 deletion(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 45a331a0679..44d5fe0e3e3 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -929,7 +929,6 @@ typedef enum { typedef VkFlags VkQueryResultFlags; typedef enum { - VK_BUFFER_USAGE_GENERAL = 0, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, From 9c93aa9141505601d862a7c85fea0679e7c63e86 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 08:52:42 -0700 Subject: [PATCH 11/76] vk: Better types for VkShaderStage, VkShaderStageFlags vars In most places, the variable type was the uninformative uint32_t. --- src/vulkan/anv_cmd_buffer.c | 15 ++++++++------- src/vulkan/anv_device.c | 2 +- src/vulkan/anv_private.h | 8 ++++---- src/vulkan/gen8_cmd_buffer.c | 5 ++--- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index c74d6d0eb17..419405204d5 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -333,7 +333,7 @@ void anv_CmdBindDescriptorSets( } if (set_layout->num_dynamic_buffers > 0) { - uint32_t s; + VkShaderStage s; for_each_bit(s, set_layout->shader_stages) { anv_cmd_buffer_ensure_push_constant_field(cmd_buffer, s, dynamic_offsets); @@ -389,7 +389,7 @@ add_surface_state_reloc(struct anv_cmd_buffer *cmd_buffer, VkResult anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, - unsigned stage, struct anv_state *bt_state) + VkShaderStage stage, struct anv_state *bt_state) { struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; struct anv_subpass *subpass = cmd_buffer->state.subpass; @@ -473,7 +473,7 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, VkResult anv_cmd_buffer_emit_samplers(struct anv_cmd_buffer *cmd_buffer, - unsigned stage, struct anv_state *state) + VkShaderStage stage, struct anv_state *state) { struct anv_pipeline_layout *layout; uint32_t sampler_count; @@ -517,7 +517,7 @@ anv_cmd_buffer_emit_samplers(struct anv_cmd_buffer *cmd_buffer, } static VkResult -flush_descriptor_set(struct anv_cmd_buffer *cmd_buffer, uint32_t stage) +flush_descriptor_set(struct anv_cmd_buffer *cmd_buffer, VkShaderStage stage) { struct anv_state surfaces = { 0, }, samplers = { 0, }; VkResult result; @@ -567,8 +567,9 @@ flush_descriptor_set(struct anv_cmd_buffer *cmd_buffer, uint32_t stage) void anv_flush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer) { - uint32_t s, dirty = cmd_buffer->state.descriptors_dirty & - cmd_buffer->state.pipeline->active_stages; + VkShaderStage s; + VkShaderStageFlags dirty = cmd_buffer->state.descriptors_dirty & + cmd_buffer->state.pipeline->active_stages; VkResult result = VK_SUCCESS; for_each_bit(s, dirty) { @@ -715,7 +716,7 @@ void anv_CmdPushConstants( const void* values) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - uint32_t stage; + VkShaderStage stage; for_each_bit(stage, stageFlags) { anv_cmd_buffer_ensure_push_constant_field(cmd_buffer, stage, client_data); diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index b6f083b4c83..dd9b08ce075 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1462,7 +1462,7 @@ VkResult anv_CreateDescriptorSetLayout( uint32_t surface_count[VK_SHADER_STAGE_NUM] = { 0, }; uint32_t num_dynamic_buffers = 0; uint32_t count = 0; - uint32_t stages = 0; + VkShaderStageFlags stages = 0; uint32_t s; for (uint32_t i = 0; i < pCreateInfo->count; i++) { diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index a2211bb76b3..29a04cab154 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -724,7 +724,7 @@ struct anv_descriptor_set_layout { uint32_t count; uint32_t num_dynamic_buffers; - uint32_t shader_stages; + VkShaderStageFlags shader_stages; struct anv_descriptor_slot entries[0]; }; @@ -828,8 +828,8 @@ struct anv_cmd_state { uint32_t vb_dirty; uint32_t dirty; uint32_t compute_dirty; - uint32_t descriptors_dirty; - uint32_t push_constants_dirty; + VkShaderStageFlags descriptors_dirty; + VkShaderStageFlags push_constants_dirty; uint32_t scratch_size; struct anv_pipeline * pipeline; struct anv_pipeline * compute_pipeline; @@ -1034,7 +1034,7 @@ struct anv_pipeline { uint32_t nr_gs_entries; } urb; - uint32_t active_stages; + VkShaderStageFlags active_stages; struct anv_state_stream program_stream; struct anv_state blend_state; uint32_t vs_simd8; diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index d82a409d886..a294e3ad50c 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -32,8 +32,6 @@ static void gen8_cmd_buffer_flush_push_constants(struct anv_cmd_buffer *cmd_buffer) { - uint32_t stage; - static const uint32_t push_constant_opcodes[] = { [VK_SHADER_STAGE_VERTEX] = 21, [VK_SHADER_STAGE_TESS_CONTROL] = 25, /* HS */ @@ -43,7 +41,8 @@ gen8_cmd_buffer_flush_push_constants(struct anv_cmd_buffer *cmd_buffer) [VK_SHADER_STAGE_COMPUTE] = 0, }; - uint32_t flushed = 0; + VkShaderStage stage; + VkShaderStageFlags flushed = 0; for_each_bit(stage, cmd_buffer->state.push_constants_dirty) { struct anv_state state = anv_cmd_buffer_push_constants(cmd_buffer, stage); From 35302240632aadd95ef97169a6013f088e9e1f17 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 08:58:35 -0700 Subject: [PATCH 12/76] vk: Annotate anv_cmd_state::gen7::index_type It's the value of 3DSTATE_INDEX_BUFFER.IndexFormat. --- src/vulkan/anv_private.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 29a04cab154..15e5124d857 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -847,7 +847,7 @@ struct anv_cmd_state { struct { struct anv_buffer * index_buffer; - uint32_t index_type; + uint32_t index_type; /**< 3DSTATE_INDEX_BUFFER.IndexFormat */ uint32_t index_offset; } gen7; }; From 4ffb4549e0aa139c908afd3c1b05e9a3ca6acf40 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 13:17:39 -0700 Subject: [PATCH 13/76] vk/image: Document a Vulkan spec requirement for depthstencil The Vulkan spec (git a511ba2) requires support for some combined depth stencil formats. --- src/vulkan/anv_image.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 2045aa27219..43245297f0e 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -546,9 +546,11 @@ anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlag anv_finishme("stencil image views"); return &image->stencil_surface; case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT: - /* FINISHME: Support combined depthstencil aspect. Does the Vulkan spec - * allow is to reject it? Until we support it, filter out the stencil - * aspect and use only the depth aspect. + /* FINISHME: The Vulkan spec (git a511ba2) requires support for combined + * depth stencil formats. Specifically, it states: + * + * At least one of ename:VK_FORMAT_D24_UNORM_S8_UINT or + * ename:VK_FORMAT_D32_SFLOAT_S8_UINT must be supported. */ anv_finishme("combined depthstencil aspect"); assert(image->format->depth_format); From 8bf021cf3dfdb50b709b7bba65dec8fd9495c74f Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 13:22:44 -0700 Subject: [PATCH 14/76] vk: Return anv_image_view_info by value The struct is only 2 bytes. Returning it on the stack is better than returning a reference into the ELF .data segment. --- src/vulkan/anv_image.c | 4 ++-- src/vulkan/anv_private.h | 2 +- src/vulkan/gen7_state.c | 4 ++-- src/vulkan/gen8_state.c | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 43245297f0e..248df3d9b42 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -61,10 +61,10 @@ anv_image_view_info_table[] = { #undef INFO }; -const struct anv_image_view_info * +struct anv_image_view_info anv_image_view_info_for_vk_image_view_type(VkImageViewType type) { - return &anv_image_view_info_table[type]; + return anv_image_view_info_table[type]; } static const struct anv_surf_type_limits { diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 15e5124d857..bc747fcd27c 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1154,7 +1154,7 @@ struct anv_image_view_info { bool is_cube:1; /**< RENDER_SURFACE_STATE.CubeFaceEnable* */ }; -const struct anv_image_view_info * +struct anv_image_view_info anv_image_view_info_for_vk_image_view_type(VkImageViewType type); /** diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index f93349da0b0..7445bf02042 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -279,7 +279,7 @@ gen7_image_view_init(struct anv_image_view *iview, const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); - const struct anv_image_view_info *view_type_info = + const struct anv_image_view_info view_type_info = anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType); if (pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D) @@ -303,7 +303,7 @@ gen7_image_view_init(struct anv_image_view *iview, } struct GEN7_RENDER_SURFACE_STATE surface_state = { - .SurfaceType = view_type_info->surface_type, + .SurfaceType = view_type_info.surface_type, .SurfaceArray = image->array_size > 1, .SurfaceFormat = format->surface_format, .SurfaceVerticalAlignment = anv_valign[surface->v_align], diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 3709a50005d..0ef44d03c44 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -158,7 +158,7 @@ gen8_image_view_init(struct anv_image_view *iview, const struct anv_format *format_info = anv_format_for_vk_format(pCreateInfo->format); - const struct anv_image_view_info *view_type_info = + const struct anv_image_view_info view_type_info = anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType); view->bo = image->bo; @@ -220,7 +220,7 @@ gen8_image_view_init(struct anv_image_view *iview, }; struct GEN8_RENDER_SURFACE_STATE surface_state = { - .SurfaceType = view_type_info->surface_type, + .SurfaceType = view_type_info.surface_type, .SurfaceArray = image->array_size > 1, .SurfaceFormat = format_info->surface_format, .SurfaceVerticalAlignment = anv_valign[surface->v_align], From 63439953d7f51700e1834e3003e209b387772b5e Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 17:02:42 -0700 Subject: [PATCH 15/76] vk: Drop dependency on no longer extant header anv_meta no longer uses GLSL shaders, and the build system no longer converts them to SPIR-V. So remove anv_meta_spirv_autogen.h from Makefile.am. (cherry picked from commit 2fc8122f66331e76ac436ea77ad5b57a011b188a) --- src/vulkan/Makefile.am | 3 +-- src/vulkan/anv_meta.c | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/vulkan/Makefile.am b/src/vulkan/Makefile.am index 765d2cef03d..eebe54d9475 100644 --- a/src/vulkan/Makefile.am +++ b/src/vulkan/Makefile.am @@ -85,8 +85,7 @@ VULKAN_SOURCES = \ BUILT_SOURCES = \ anv_entrypoints.h \ - anv_entrypoints.c \ - anv_meta_spirv_autogen.h + anv_entrypoints.c if HAVE_EGL_PLATFORM_WAYLAND BUILT_SOURCES += \ diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index dd8f3a958a6..e1bec386fe4 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -28,7 +28,6 @@ #include #include "anv_private.h" -#include "anv_meta_spirv_autogen.h" #include "anv_nir_builder.h" static nir_shader * From ffd051830d837705f4da6d16e59953b02066c91e Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 14:43:23 -0700 Subject: [PATCH 16/76] vk: Unionize anv_desciptor For a given struct anv_descriptor, all members are NULL (in which case the descriptor is empty) or exactly one member is non-NULL. To make struct anv_descriptor better reflect its set of valid states, convert the struct into a tagged union. --- src/vulkan/anv_cmd_buffer.c | 16 ++++++++++------ src/vulkan/anv_device.c | 21 +++++++++++++++++---- src/vulkan/anv_private.h | 14 ++++++++++++-- 3 files changed, 39 insertions(+), 12 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 419405204d5..5a00ce24bd2 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -456,12 +456,14 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, uint32_t start = bias + layout->set[set].stage[stage].surface_start; for (uint32_t b = 0; b < set_layout->stage[stage].surface_count; b++) { - struct anv_surface_view *view = - d->set->descriptors[surface_slots[b].index].view; + struct anv_descriptor *desc = + &d->set->descriptors[surface_slots[b].index]; - if (!view) + if (desc->type != ANV_DESCRIPTOR_TYPE_SURFACE_VIEW) continue; + struct anv_surface_view *view = desc->surface_view; + bt_map[start + b] = view->surface_state.offset + state_offset; add_surface_state_reloc(cmd_buffer, view->surface_state, view->bo, view->offset); @@ -502,12 +504,14 @@ anv_cmd_buffer_emit_samplers(struct anv_cmd_buffer *cmd_buffer, uint32_t start = layout->set[set].stage[stage].sampler_start; for (uint32_t b = 0; b < set_layout->stage[stage].sampler_count; b++) { - struct anv_sampler *sampler = - d->set->descriptors[sampler_slots[b].index].sampler; + struct anv_descriptor *desc = + &d->set->descriptors[sampler_slots[b].index]; - if (!sampler) + if (desc->type != ANV_DESCRIPTOR_TYPE_SAMPLER) continue; + struct anv_sampler *sampler = desc->sampler; + memcpy(state->map + (start + b) * 16, sampler->state, sizeof(sampler->state)); } diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index dd9b08ce075..7889c61ba5b 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1733,8 +1733,13 @@ VkResult anv_UpdateDescriptorSets( case VK_DESCRIPTOR_TYPE_SAMPLER: case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: for (uint32_t j = 0; j < write->count; j++) { - set->descriptors[write->destBinding + j].sampler = - anv_sampler_from_handle(write->pDescriptors[j].sampler); + ANV_FROM_HANDLE(anv_sampler, sampler, + write->pDescriptors[j].sampler); + + set->descriptors[write->destBinding + j] = (struct anv_descriptor) { + .type = ANV_DESCRIPTOR_TYPE_SAMPLER, + .sampler = sampler, + }; } if (write->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) @@ -1747,7 +1752,11 @@ VkResult anv_UpdateDescriptorSets( for (uint32_t j = 0; j < write->count; j++) { ANV_FROM_HANDLE(anv_image_view, iview, write->pDescriptors[j].imageView); - set->descriptors[write->destBinding + j].view = &iview->view; + + set->descriptors[write->destBinding + j] = (struct anv_descriptor) { + .type = ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, + .surface_view = &iview->view, + }; } break; @@ -1767,7 +1776,11 @@ VkResult anv_UpdateDescriptorSets( for (uint32_t j = 0; j < write->count; j++) { ANV_FROM_HANDLE(anv_buffer_view, bview, write->pDescriptors[j].bufferView); - set->descriptors[write->destBinding + j].view = &bview->view; + + set->descriptors[write->destBinding + j] = (struct anv_descriptor) { + .type = ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, + .surface_view = &bview->view, + }; } default: diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index bc747fcd27c..6ce5db209cb 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -728,9 +728,19 @@ struct anv_descriptor_set_layout { struct anv_descriptor_slot entries[0]; }; +enum anv_descriptor_type { + ANV_DESCRIPTOR_TYPE_EMPTY = 0, + ANV_DESCRIPTOR_TYPE_SAMPLER, + ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, +}; + struct anv_descriptor { - struct anv_sampler *sampler; - struct anv_surface_view *view; + union { + struct anv_sampler *sampler; + struct anv_surface_view *surface_view; + }; + + enum anv_descriptor_type type; }; struct anv_descriptor_set { From 74193a880f475da40e8c03ff7e772f3a288317a8 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 15:49:10 -0700 Subject: [PATCH 17/76] vk: Use consistent names for anv_*_view variables Rename all anv_*_view variables to follow this convention: - sview -> anv_surface_view - bview -> anv_buffer_view - iview -> anv_image_view - aview -> anv_attachment_view - cview -> anv_color_attachment_view - ds_view -> anv_depth_stencil_attachment_view This clarifies existing code. And it will reduce noise in the upcoming commits that merge VkAttachmentView into VkImageView. --- src/vulkan/anv_cmd_buffer.c | 25 ++++--- src/vulkan/anv_device.c | 24 +++---- src/vulkan/anv_image.c | 57 ++++++++-------- src/vulkan/anv_meta.c | 125 ++++++++++++++++++----------------- src/vulkan/anv_private.h | 20 +++--- src/vulkan/gen7_cmd_buffer.c | 12 ++-- src/vulkan/gen7_state.c | 54 ++++++++------- src/vulkan/gen8_cmd_buffer.c | 12 ++-- src/vulkan/gen8_state.c | 54 ++++++++------- 9 files changed, 200 insertions(+), 183 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 5a00ce24bd2..50f8304f9b3 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -432,16 +432,19 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, * put the color attachments into the binding table. */ for (uint32_t a = 0; a < attachments; a++) { - const struct anv_attachment_view *attachment = + const struct anv_attachment_view *aview = fb->attachments[subpass->color_attachments[a]]; - assert(attachment->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR); - const struct anv_color_attachment_view *view = - (const struct anv_color_attachment_view *)attachment; + assert(aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR); - bt_map[a] = view->view.surface_state.offset + state_offset; - add_surface_state_reloc(cmd_buffer, view->view.surface_state, - view->view.bo, view->view.offset); + const struct anv_color_attachment_view *cview = + (const struct anv_color_attachment_view *) aview; + + const struct anv_surface_view *sview = &cview->surface_view; + + bt_map[a] = sview->surface_state.offset + state_offset; + add_surface_state_reloc(cmd_buffer, sview->surface_state, + sview->bo, sview->offset); } if (layout == NULL) @@ -462,11 +465,11 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, if (desc->type != ANV_DESCRIPTOR_TYPE_SURFACE_VIEW) continue; - struct anv_surface_view *view = desc->surface_view; + const struct anv_surface_view *sview = desc->surface_view; - bt_map[start + b] = view->surface_state.offset + state_offset; - add_surface_state_reloc(cmd_buffer, view->surface_state, - view->bo, view->offset); + bt_map[start + b] = sview->surface_state.offset + state_offset; + add_surface_state_reloc(cmd_buffer, sview->surface_state, + sview->bo, sview->offset); } } diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 7889c61ba5b..b2c8027fcf9 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1396,19 +1396,19 @@ VkResult anv_buffer_view_create( struct anv_device * device, const VkBufferViewCreateInfo* pCreateInfo, - struct anv_buffer_view ** view_out) + struct anv_buffer_view ** bview_out) { ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer); - struct anv_buffer_view *view; + struct anv_buffer_view *bview; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO); - view = anv_device_alloc(device, sizeof(*view), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (view == NULL) + bview = anv_device_alloc(device, sizeof(*bview), 8, + VK_SYSTEM_ALLOC_TYPE_API_OBJECT); + if (bview == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - view->view = (struct anv_surface_view) { + bview->surface_view = (struct anv_surface_view) { .bo = buffer->bo, .offset = buffer->offset + pCreateInfo->offset, .surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64), @@ -1416,7 +1416,7 @@ anv_buffer_view_create( .range = pCreateInfo->range, }; - *view_out = view; + *bview_out = bview; return VK_SUCCESS; } @@ -1428,7 +1428,7 @@ VkResult anv_DestroyBufferView( ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_buffer_view, bview, _bview); - anv_surface_view_fini(device, &bview->view); + anv_surface_view_fini(device, &bview->surface_view); anv_device_free(device, bview); return VK_SUCCESS; @@ -1755,7 +1755,7 @@ VkResult anv_UpdateDescriptorSets( set->descriptors[write->destBinding + j] = (struct anv_descriptor) { .type = ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, - .surface_view = &iview->view, + .surface_view = &iview->surface_view, }; } break; @@ -1779,7 +1779,7 @@ VkResult anv_UpdateDescriptorSets( set->descriptors[write->destBinding + j] = (struct anv_descriptor) { .type = ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, - .surface_view = &bview->view, + .surface_view = &bview->surface_view, }; } @@ -2001,10 +2001,10 @@ VkResult anv_CreateFramebuffer( framebuffer->attachment_count = pCreateInfo->attachmentCount; for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { - ANV_FROM_HANDLE(anv_attachment_view, view, + ANV_FROM_HANDLE(anv_attachment_view, aview, pCreateInfo->pAttachments[i].view); - framebuffer->attachments[i] = view; + framebuffer->attachments[i] = aview; } framebuffer->width = pCreateInfo->width; diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 248df3d9b42..19004320298 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -374,9 +374,9 @@ VkResult anv_GetImageSubresourceLayout( void anv_surface_view_fini(struct anv_device *device, - struct anv_surface_view *view) + struct anv_surface_view *sview) { - anv_state_pool_free(&device->surface_state_pool, view->surface_state); + anv_state_pool_free(&device->surface_state_pool, sview->surface_state); } VkResult @@ -505,30 +505,31 @@ anv_DestroyImageView(VkDevice _device, VkImageView _iview) ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_image_view, iview, _iview); - anv_surface_view_fini(device, &iview->view); + anv_surface_view_fini(device, &iview->surface_view); anv_device_free(device, iview); return VK_SUCCESS; } static void -anv_depth_stencil_view_init(struct anv_depth_stencil_view *view, +anv_depth_stencil_view_init(struct anv_depth_stencil_view *ds_view, const VkAttachmentViewCreateInfo *pCreateInfo) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - view->base.attachment_type = ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL; + ds_view->attachment_view.attachment_type = + ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL; /* XXX: We don't handle any of these */ anv_assert(pCreateInfo->mipLevel == 0); anv_assert(pCreateInfo->baseArraySlice == 0); anv_assert(pCreateInfo->arraySize == 1); - view->image = image; - view->format = anv_format_for_vk_format(pCreateInfo->format); + ds_view->image = image; + ds_view->format = anv_format_for_vk_format(pCreateInfo->format); assert(anv_format_is_depth_or_stencil(image->format)); - assert(anv_format_is_depth_or_stencil(view->format)); + assert(anv_format_is_depth_or_stencil(ds_view->format)); } struct anv_surface * @@ -578,17 +579,17 @@ anv_image_get_surface_for_color_attachment(struct anv_image *image) } void -anv_color_attachment_view_init(struct anv_color_attachment_view *aview, +anv_color_attachment_view_init(struct anv_color_attachment_view *cview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { switch (device->info.gen) { case 7: - gen7_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer); + gen7_color_attachment_view_init(cview, device, pCreateInfo, cmd_buffer); break; case 8: - gen8_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer); + gen8_color_attachment_view_init(cview, device, pCreateInfo, cmd_buffer); break; default: unreachable("unsupported gen\n"); @@ -608,44 +609,44 @@ anv_CreateAttachmentView(VkDevice _device, anv_format_for_vk_format(pCreateInfo->format); if (anv_format_is_depth_or_stencil(format)) { - struct anv_depth_stencil_view *view = - anv_device_alloc(device, sizeof(*view), 8, + struct anv_depth_stencil_view *ds_view = + anv_device_alloc(device, sizeof(*ds_view), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (view == NULL) + if (ds_view == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - anv_depth_stencil_view_init(view, pCreateInfo); + anv_depth_stencil_view_init(ds_view, pCreateInfo); - *pView = anv_attachment_view_to_handle(&view->base); + *pView = anv_attachment_view_to_handle(&ds_view->attachment_view); } else { - struct anv_color_attachment_view *view = - anv_device_alloc(device, sizeof(*view), 8, + struct anv_color_attachment_view *cview = + anv_device_alloc(device, sizeof(*cview), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (view == NULL) + if (cview == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - anv_color_attachment_view_init(view, device, pCreateInfo, NULL); + anv_color_attachment_view_init(cview, device, pCreateInfo, NULL); - *pView = anv_attachment_view_to_handle(&view->base); + *pView = anv_attachment_view_to_handle(&cview->attachment_view); } return VK_SUCCESS; } VkResult -anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _view) +anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) { ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_attachment_view, view, _view); + ANV_FROM_HANDLE(anv_attachment_view, aview, _aview); - if (view->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR) { - struct anv_color_attachment_view *aview = - (struct anv_color_attachment_view *)view; + if (aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR) { + struct anv_color_attachment_view *cview = + (struct anv_color_attachment_view *) aview; - anv_surface_view_fini(device, &aview->view); + anv_surface_view_fini(device, &cview->surface_view); } - anv_device_free(device, view); + anv_device_free(device, aview); return VK_SUCCESS; } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index e1bec386fe4..fe235e23fb0 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -729,15 +729,17 @@ struct blit_region { static void meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, struct anv_image *src_image, - struct anv_image_view *src_view, + struct anv_image_view *src_iview, VkOffset3D src_offset, VkExtent3D src_extent, struct anv_image *dest_image, - struct anv_color_attachment_view *dest_view, + struct anv_color_attachment_view *dest_cview, VkOffset3D dest_offset, VkExtent3D dest_extent) { struct anv_device *device = cmd_buffer->device; + struct anv_attachment_view *dest_aview = &dest_cview->attachment_view; + struct anv_surface_view *dest_sview = &dest_cview->surface_view; VkDescriptorPool dummy_desc_pool = { .handle = 1 }; struct blit_vb_data { @@ -758,9 +760,9 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, dest_offset.y + dest_extent.height, }, .tex_coord = { - (float)(src_offset.x + src_extent.width) / (float)src_view->extent.width, - (float)(src_offset.y + src_extent.height) / (float)src_view->extent.height, - (float)(src_offset.z + src_extent.depth) / (float)src_view->extent.depth, + (float)(src_offset.x + src_extent.width) / (float)src_iview->extent.width, + (float)(src_offset.y + src_extent.height) / (float)src_iview->extent.height, + (float)(src_offset.z + src_extent.depth) / (float)src_iview->extent.depth, }, }; @@ -770,9 +772,9 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, dest_offset.y + dest_extent.height, }, .tex_coord = { - (float)src_offset.x / (float)src_view->extent.width, - (float)(src_offset.y + src_extent.height) / (float)src_view->extent.height, - (float)(src_offset.z + src_extent.depth) / (float)src_view->extent.depth, + (float)src_offset.x / (float)src_iview->extent.width, + (float)(src_offset.y + src_extent.height) / (float)src_iview->extent.height, + (float)(src_offset.z + src_extent.depth) / (float)src_iview->extent.depth, }, }; @@ -782,9 +784,9 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, dest_offset.y, }, .tex_coord = { - (float)src_offset.x / (float)src_view->extent.width, - (float)src_offset.y / (float)src_view->extent.height, - (float)src_offset.z / (float)src_view->extent.depth, + (float)src_offset.x / (float)src_iview->extent.width, + (float)src_offset.y / (float)src_iview->extent.height, + (float)src_offset.z / (float)src_iview->extent.depth, }, }; @@ -822,7 +824,7 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, .pDescriptors = (VkDescriptorInfo[]) { { - .imageView = anv_image_view_to_handle(src_view), + .imageView = anv_image_view_to_handle(src_iview), .imageLayout = VK_IMAGE_LAYOUT_GENERAL }, } @@ -836,12 +838,12 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .attachmentCount = 1, .pAttachments = (VkAttachmentBindInfo[]) { { - .view = anv_attachment_view_to_handle(&dest_view->base), + .view = anv_attachment_view_to_handle(dest_aview), .layout = VK_IMAGE_LAYOUT_GENERAL } }, - .width = dest_view->base.extent.width, - .height = dest_view->base.extent.height, + .width = dest_aview->extent.width, + .height = dest_aview->extent.height, .layers = 1 }, &fb); @@ -852,7 +854,7 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .attachmentCount = 1, .pAttachments = &(VkAttachmentDescription) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, - .format = dest_view->view.format->vk_format, + .format = dest_sview->format->vk_format, .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, .storeOp = VK_ATTACHMENT_STORE_OP_STORE, .initialLayout = VK_IMAGE_LAYOUT_GENERAL, @@ -998,8 +1000,8 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, anv_image_from_handle(dest_image)->bo = dest; anv_image_from_handle(dest_image)->offset = dest_offset; - struct anv_image_view src_view; - anv_image_view_init(&src_view, cmd_buffer->device, + struct anv_image_view src_iview; + anv_image_view_init(&src_iview, cmd_buffer->device, &(VkImageViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = src_image, @@ -1021,8 +1023,8 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, }, cmd_buffer); - struct anv_color_attachment_view dest_view; - anv_color_attachment_view_init(&dest_view, cmd_buffer->device, + struct anv_color_attachment_view dest_cview; + anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = dest_image, @@ -1035,11 +1037,11 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, meta_emit_blit(cmd_buffer, anv_image_from_handle(src_image), - &src_view, + &src_iview, (VkOffset3D) { 0, 0, 0 }, (VkExtent3D) { width, height, 1 }, anv_image_from_handle(dest_image), - &dest_view, + &dest_cview, (VkOffset3D) { 0, 0, 0 }, (VkExtent3D) { width, height, 1 }); @@ -1138,7 +1140,7 @@ void anv_CmdCopyImage( ANV_FROM_HANDLE(anv_image, src_image, srcImage); ANV_FROM_HANDLE(anv_image, dest_image, destImage); - const VkImageViewType src_view_type = + const VkImageViewType src_iview_type = meta_blit_get_src_image_view_type(src_image); struct anv_saved_state saved_state; @@ -1146,12 +1148,12 @@ void anv_CmdCopyImage( meta_prepare_blit(cmd_buffer, &saved_state); for (unsigned r = 0; r < regionCount; r++) { - struct anv_image_view src_view; - anv_image_view_init(&src_view, cmd_buffer->device, + struct anv_image_view src_iview; + anv_image_view_init(&src_iview, cmd_buffer->device, &(VkImageViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = srcImage, - .viewType = src_view_type, + .viewType = src_iview_type, .format = src_image->format->vk_format, .channels = { VK_CHANNEL_SWIZZLE_R, @@ -1183,8 +1185,8 @@ void anv_CmdCopyImage( if (pRegions[r].extent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_color_attachment_view dest_view; - anv_color_attachment_view_init(&dest_view, cmd_buffer->device, + struct anv_color_attachment_view dest_cview; + anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1196,10 +1198,10 @@ void anv_CmdCopyImage( cmd_buffer); meta_emit_blit(cmd_buffer, - src_image, &src_view, + src_image, &src_iview, pRegions[r].srcOffset, pRegions[r].extent, - dest_image, &dest_view, + dest_image, &dest_cview, dest_offset, pRegions[r].extent); } @@ -1222,7 +1224,7 @@ void anv_CmdBlitImage( ANV_FROM_HANDLE(anv_image, src_image, srcImage); ANV_FROM_HANDLE(anv_image, dest_image, destImage); - const VkImageViewType src_view_type = + const VkImageViewType src_iview_type = meta_blit_get_src_image_view_type(src_image); struct anv_saved_state saved_state; @@ -1232,12 +1234,12 @@ void anv_CmdBlitImage( meta_prepare_blit(cmd_buffer, &saved_state); for (unsigned r = 0; r < regionCount; r++) { - struct anv_image_view src_view; - anv_image_view_init(&src_view, cmd_buffer->device, + struct anv_image_view src_iview; + anv_image_view_init(&src_iview, cmd_buffer->device, &(VkImageViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = srcImage, - .viewType = src_view_type, + .viewType = src_iview_type, .format = src_image->format->vk_format, .channels = { VK_CHANNEL_SWIZZLE_R, @@ -1269,8 +1271,8 @@ void anv_CmdBlitImage( if (pRegions[r].destExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_color_attachment_view dest_view; - anv_color_attachment_view_init(&dest_view, cmd_buffer->device, + struct anv_color_attachment_view dest_cview; + anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1282,10 +1284,10 @@ void anv_CmdBlitImage( cmd_buffer); meta_emit_blit(cmd_buffer, - src_image, &src_view, + src_image, &src_iview, pRegions[r].srcOffset, pRegions[r].srcExtent, - dest_image, &dest_view, + dest_image, &dest_cview, dest_offset, pRegions[r].destExtent); } @@ -1362,8 +1364,8 @@ void anv_CmdCopyBufferToImage( proxy_format, &pRegions[r]); - struct anv_image_view src_view; - anv_image_view_init(&src_view, cmd_buffer->device, + struct anv_image_view src_iview; + anv_image_view_init(&src_iview, cmd_buffer->device, &(VkImageViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = srcImage, @@ -1399,8 +1401,8 @@ void anv_CmdCopyBufferToImage( if (pRegions[r].imageExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_color_attachment_view dest_view; - anv_color_attachment_view_init(&dest_view, cmd_buffer->device, + struct anv_color_attachment_view dest_cview; + anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = anv_image_to_handle(dest_image), @@ -1413,11 +1415,11 @@ void anv_CmdCopyBufferToImage( meta_emit_blit(cmd_buffer, anv_image_from_handle(srcImage), - &src_view, + &src_iview, (VkOffset3D) { 0, 0, 0 }, pRegions[r].imageExtent, dest_image, - &dest_view, + &dest_cview, dest_offset, pRegions[r].imageExtent); @@ -1440,7 +1442,7 @@ void anv_CmdCopyImageToBuffer( VkDevice vk_device = anv_device_to_handle(cmd_buffer->device); struct anv_saved_state saved_state; - const VkImageViewType src_view_type = + const VkImageViewType src_iview_type = meta_blit_get_src_image_view_type(src_image); meta_prepare_blit(cmd_buffer, &saved_state); @@ -1449,12 +1451,12 @@ void anv_CmdCopyImageToBuffer( if (pRegions[r].imageExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_image_view src_view; - anv_image_view_init(&src_view, cmd_buffer->device, + struct anv_image_view src_iview; + anv_image_view_init(&src_iview, cmd_buffer->device, &(VkImageViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = srcImage, - .viewType = src_view_type, + .viewType = src_iview_type, .format = src_image->format->vk_format, .channels = { VK_CHANNEL_SWIZZLE_R, @@ -1481,8 +1483,8 @@ void anv_CmdCopyImageToBuffer( dest_format, &pRegions[r]); - struct anv_color_attachment_view dest_view; - anv_color_attachment_view_init(&dest_view, cmd_buffer->device, + struct anv_color_attachment_view dest_cview; + anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1495,11 +1497,11 @@ void anv_CmdCopyImageToBuffer( meta_emit_blit(cmd_buffer, anv_image_from_handle(srcImage), - &src_view, + &src_iview, pRegions[r].imageOffset, pRegions[r].imageExtent, anv_image_from_handle(destImage), - &dest_view, + &dest_cview, (VkOffset3D) { 0, 0, 0 }, pRegions[r].imageExtent); @@ -1546,8 +1548,8 @@ void anv_CmdClearColorImage( for (uint32_t r = 0; r < rangeCount; r++) { for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { for (uint32_t s = 0; s < pRanges[r].arraySize; s++) { - struct anv_color_attachment_view view; - anv_color_attachment_view_init(&view, cmd_buffer->device, + struct anv_color_attachment_view cview; + anv_color_attachment_view_init(&cview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = _image, @@ -1558,6 +1560,9 @@ void anv_CmdClearColorImage( }, cmd_buffer); + struct anv_attachment_view *aview = &cview.attachment_view; + struct anv_surface_view *sview = &cview.surface_view; + VkFramebuffer fb; anv_CreateFramebuffer(anv_device_to_handle(cmd_buffer->device), &(VkFramebufferCreateInfo) { @@ -1565,12 +1570,12 @@ void anv_CmdClearColorImage( .attachmentCount = 1, .pAttachments = (VkAttachmentBindInfo[]) { { - .view = anv_attachment_view_to_handle(&view.base), + .view = anv_attachment_view_to_handle(aview), .layout = VK_IMAGE_LAYOUT_GENERAL } }, - .width = view.base.extent.width, - .height = view.base.extent.height, + .width = aview->extent.width, + .height = aview->extent.height, .layers = 1 }, &fb); @@ -1581,7 +1586,7 @@ void anv_CmdClearColorImage( .attachmentCount = 1, .pAttachments = &(VkAttachmentDescription) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, - .format = view.view.format->vk_format, + .format = sview->format->vk_format, .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, .storeOp = VK_ATTACHMENT_STORE_OP_STORE, .initialLayout = VK_IMAGE_LAYOUT_GENERAL, @@ -1617,8 +1622,8 @@ void anv_CmdClearColorImage( .renderArea = { .offset = { 0, 0, }, .extent = { - .width = view.base.extent.width, - .height = view.base.extent.height, + .width = aview->extent.width, + .height = aview->extent.height, }, }, .renderPass = pass, diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 6ce5db209cb..09890730fd6 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1242,11 +1242,11 @@ struct anv_surface_view { }; struct anv_buffer_view { - struct anv_surface_view view; + struct anv_surface_view surface_view; }; struct anv_image_view { - struct anv_surface_view view; + struct anv_surface_view surface_view; VkExtent3D extent; }; @@ -1261,12 +1261,12 @@ struct anv_attachment_view { }; struct anv_color_attachment_view { - struct anv_attachment_view base; - struct anv_surface_view view; + struct anv_attachment_view attachment_view; + struct anv_surface_view surface_view; }; struct anv_depth_stencil_view { - struct anv_attachment_view base; + struct anv_attachment_view attachment_view; const struct anv_image *image; /**< VkAttachmentViewCreateInfo::image */ const struct anv_format *format; /**< VkAttachmentViewCreateInfo::format */ }; @@ -1306,24 +1306,24 @@ gen8_image_view_init(struct anv_image_view *iview, const VkImageViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void anv_color_attachment_view_init(struct anv_color_attachment_view *view, +void anv_color_attachment_view_init(struct anv_color_attachment_view *cview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void gen7_color_attachment_view_init(struct anv_color_attachment_view *aview, +void gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void gen8_color_attachment_view_init(struct anv_color_attachment_view *aview, +void gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); VkResult anv_buffer_view_create(struct anv_device *device, const VkBufferViewCreateInfo *pCreateInfo, - struct anv_buffer_view **view_out); + struct anv_buffer_view **bview_out); void anv_fill_buffer_surface_state(struct anv_device *device, void *state, const struct anv_format *format, @@ -1335,7 +1335,7 @@ void gen8_fill_buffer_surface_state(void *state, const struct anv_format *format uint32_t offset, uint32_t range); void anv_surface_view_fini(struct anv_device *device, - struct anv_surface_view *view); + struct anv_surface_view *sview); struct anv_sampler { uint32_t state[4]; diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index 323022b13f9..b264013d62e 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -529,20 +529,20 @@ static void gen7_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) { const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; - const struct anv_depth_stencil_view *view = + const struct anv_depth_stencil_view *ds_view = anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); - const struct anv_image *image = view ? view->image : NULL; - const bool has_depth = view && view->format->depth_format; - const bool has_stencil = view && view->format->has_stencil; + const struct anv_image *image = ds_view ? ds_view->image : NULL; + const bool has_depth = ds_view && ds_view->format->depth_format; + const bool has_stencil = ds_view && ds_view->format->has_stencil; /* Emit 3DSTATE_DEPTH_BUFFER */ if (has_depth) { anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_DEPTH_BUFFER, .SurfaceType = SURFTYPE_2D, - .DepthWriteEnable = view->format->depth_format, + .DepthWriteEnable = ds_view->format->depth_format, .StencilWriteEnable = has_stencil, .HierarchicalDepthBufferEnable = false, - .SurfaceFormat = view->format->depth_format, + .SurfaceFormat = ds_view->format->depth_format, .SurfacePitch = image->depth_surface.stride - 1, .SurfaceBaseAddress = { .bo = image->bo, diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 7445bf02042..a782690718b 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -65,20 +65,21 @@ VkResult gen7_CreateBufferView( VkBufferView* pView) { ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_buffer_view *view; + struct anv_buffer_view *bview; VkResult result; - result = anv_buffer_view_create(device, pCreateInfo, &view); + result = anv_buffer_view_create(device, pCreateInfo, &bview); if (result != VK_SUCCESS) return result; const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); - gen7_fill_buffer_surface_state(view->view.surface_state.map, format, - view->view.offset, pCreateInfo->range); + gen7_fill_buffer_surface_state(bview->surface_view.surface_state.map, + format, bview->surface_view.offset, + pCreateInfo->range); - *pView = anv_buffer_view_to_handle(view); + *pView = anv_buffer_view_to_handle(bview); return VK_SUCCESS; } @@ -272,7 +273,7 @@ gen7_image_view_init(struct anv_image_view *iview, ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; - struct anv_surface_view *view = &iview->view; + struct anv_surface_view *sview = &iview->surface_view; struct anv_surface *surface = anv_image_get_surface_for_aspect_mask(image, range->aspectMask); @@ -285,9 +286,9 @@ gen7_image_view_init(struct anv_image_view *iview, if (pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D) anv_finishme("non-2D image views"); - view->bo = image->bo; - view->offset = image->offset + surface->offset; - view->format = anv_format_for_vk_format(pCreateInfo->format); + sview->bo = image->bo; + sview->offset = image->offset + surface->offset; + sview->format = anv_format_for_vk_format(pCreateInfo->format); iview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, range->baseMipLevel), @@ -345,42 +346,44 @@ gen7_image_view_init(struct anv_image_view *iview, .BlueClearColor = 0, .AlphaClearColor = 0, .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, view->offset }, + .SurfaceBaseAddress = { NULL, sview->offset }, }; if (cmd_buffer) { - view->surface_state = + sview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - view->surface_state = + sview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } - GEN7_RENDER_SURFACE_STATE_pack(NULL, view->surface_state.map, &surface_state); + GEN7_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + &surface_state); } void -gen7_color_attachment_view_init(struct anv_color_attachment_view *aview, +gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_surface_view *view = &aview->view; + struct anv_attachment_view *aview = &cview->attachment_view; + struct anv_surface_view *sview = &cview->surface_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); - aview->base.attachment_type = ANV_ATTACHMENT_VIEW_TYPE_COLOR; + aview->attachment_type = ANV_ATTACHMENT_VIEW_TYPE_COLOR; anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); - view->bo = image->bo; - view->offset = image->offset + surface->offset; - view->format = anv_format_for_vk_format(pCreateInfo->format); + sview->bo = image->bo; + sview->offset = image->offset + surface->offset; + sview->format = anv_format_for_vk_format(pCreateInfo->format); - aview->base.extent = (VkExtent3D) { + aview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), .height = anv_minify(image->extent.height, pCreateInfo->mipLevel), .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel), @@ -394,17 +397,17 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *aview, } if (cmd_buffer) { - view->surface_state = + sview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - view->surface_state = + sview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } struct GEN7_RENDER_SURFACE_STATE surface_state = { .SurfaceType = SURFTYPE_2D, .SurfaceArray = image->array_size > 1, - .SurfaceFormat = view->format->surface_format, + .SurfaceFormat = sview->format->surface_format, .SurfaceVerticalAlignment = anv_valign[surface->v_align], .SurfaceHorizontalAlignment = anv_halign[surface->h_align], @@ -444,9 +447,10 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *aview, .BlueClearColor = 0, .AlphaClearColor = 0, .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, view->offset }, + .SurfaceBaseAddress = { NULL, sview->offset }, }; - GEN7_RENDER_SURFACE_STATE_pack(NULL, view->surface_state.map, &surface_state); + GEN7_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + &surface_state); } diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index a294e3ad50c..30573639986 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -458,11 +458,11 @@ static void gen8_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) { const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; - const struct anv_depth_stencil_view *view = + const struct anv_depth_stencil_view *ds_view = anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); - const struct anv_image *image = view ? view->image : NULL; - const bool has_depth = view && view->format->depth_format; - const bool has_stencil = view && view->format->has_stencil; + const struct anv_image *image = ds_view ? ds_view->image : NULL; + const bool has_depth = ds_view && ds_view->format->depth_format; + const bool has_stencil = ds_view && ds_view->format->has_stencil; /* FIXME: Implement the PMA stall W/A */ /* FIXME: Width and Height are wrong */ @@ -471,10 +471,10 @@ gen8_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) if (has_depth) { anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DEPTH_BUFFER, .SurfaceType = SURFTYPE_2D, - .DepthWriteEnable = view->format->depth_format, + .DepthWriteEnable = ds_view->format->depth_format, .StencilWriteEnable = has_stencil, .HierarchicalDepthBufferEnable = false, - .SurfaceFormat = view->format->depth_format, + .SurfaceFormat = ds_view->format->depth_format, .SurfacePitch = image->depth_surface.stride - 1, .SurfaceBaseAddress = { .bo = image->bo, diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 0ef44d03c44..c47d317d2a3 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -109,20 +109,21 @@ VkResult gen8_CreateBufferView( VkBufferView* pView) { ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_buffer_view *view; + struct anv_buffer_view *bview; VkResult result; - result = anv_buffer_view_create(device, pCreateInfo, &view); + result = anv_buffer_view_create(device, pCreateInfo, &bview); if (result != VK_SUCCESS) return result; const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); - gen8_fill_buffer_surface_state(view->view.surface_state.map, format, - view->view.offset, pCreateInfo->range); + gen8_fill_buffer_surface_state(bview->surface_view.surface_state.map, + format, bview->surface_view.offset, + pCreateInfo->range); - *pView = anv_buffer_view_to_handle(view); + *pView = anv_buffer_view_to_handle(bview); return VK_SUCCESS; } @@ -148,7 +149,7 @@ gen8_image_view_init(struct anv_image_view *iview, ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; - struct anv_surface_view *view = &iview->view; + struct anv_surface_view *sview = &iview->surface_view; struct anv_surface *surface = anv_image_get_surface_for_aspect_mask(image, range->aspectMask); @@ -161,9 +162,9 @@ gen8_image_view_init(struct anv_image_view *iview, const struct anv_image_view_info view_type_info = anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType); - view->bo = image->bo; - view->offset = image->offset + surface->offset; - view->format = format_info; + sview->bo = image->bo; + sview->offset = image->offset + surface->offset; + sview->format = format_info; iview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, range->baseMipLevel), @@ -266,28 +267,30 @@ gen8_image_view_init(struct anv_image_view *iview, .ShaderChannelSelectBlue = vk_to_gen_swizzle[pCreateInfo->channels.b], .ShaderChannelSelectAlpha = vk_to_gen_swizzle[pCreateInfo->channels.a], .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, view->offset }, + .SurfaceBaseAddress = { NULL, sview->offset }, }; if (cmd_buffer) { - view->surface_state = + sview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - view->surface_state = + sview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } - GEN8_RENDER_SURFACE_STATE_pack(NULL, view->surface_state.map, &surface_state); + GEN8_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + &surface_state); } void -gen8_color_attachment_view_init(struct anv_color_attachment_view *aview, +gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_surface_view *view = &aview->view; + struct anv_attachment_view *aview = &cview->attachment_view; + struct anv_surface_view *sview = &cview->surface_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); const struct anv_format *format_info = @@ -296,17 +299,17 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *aview, uint32_t depth = 1; /* RENDER_SURFACE_STATE::Depth */ uint32_t rt_view_extent = 1; /* RENDER_SURFACE_STATE::RenderTargetViewExtent */ - aview->base.attachment_type = ANV_ATTACHMENT_VIEW_TYPE_COLOR; + aview->attachment_type = ANV_ATTACHMENT_VIEW_TYPE_COLOR; anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); - view->bo = image->bo; - view->offset = image->offset + surface->offset; - view->format = anv_format_for_vk_format(pCreateInfo->format); + sview->bo = image->bo; + sview->offset = image->offset + surface->offset; + sview->format = anv_format_for_vk_format(pCreateInfo->format); - aview->base.extent = (VkExtent3D) { + aview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), .height = anv_minify(image->extent.height, pCreateInfo->mipLevel), .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel), @@ -345,17 +348,17 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *aview, * indicates the extent of the accessible 'R' coordinates minus 1 on * the LOD currently being rendered to. */ - rt_view_extent = aview->base.extent.depth; + rt_view_extent = aview->extent.depth; break; default: unreachable(!"bad VkImageType"); } if (cmd_buffer) { - view->surface_state = + sview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - view->surface_state = + sview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } @@ -408,10 +411,11 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *aview, .ShaderChannelSelectBlue = SCS_BLUE, .ShaderChannelSelectAlpha = SCS_ALPHA, .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, view->offset }, + .SurfaceBaseAddress = { NULL, sview->offset }, }; - GEN8_RENDER_SURFACE_STATE_pack(NULL, view->surface_state.map, &surface_state); + GEN8_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + &surface_state); } VkResult gen8_CreateSampler( From f0f4dfa9cc1473c5e12eeeb9403f721d5611e905 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 16:24:53 -0700 Subject: [PATCH 18/76] vk: Drop anv_surface_view Push the members of struct anv_surface_view into anv_image_view and anv_buffer_view, then remove struct anv_surface_view. Observe that anv_surface_view::range is not needed for anv_image_view, and so was dropped there. This prepares for the merge of VkAttachmentView into VkImageView. Remove the common parent of anv_buffer_view and anv_image_view (that is, anv_surface_view) will make the merge easier. --- src/vulkan/anv_cmd_buffer.c | 34 +++++++++++++++++++++++---------- src/vulkan/anv_device.c | 12 ++++++------ src/vulkan/anv_image.c | 18 +++++++++--------- src/vulkan/anv_meta.c | 8 ++++---- src/vulkan/anv_private.h | 28 +++++++++++++-------------- src/vulkan/gen7_state.c | 38 ++++++++++++++++++------------------- src/vulkan/gen8_state.c | 36 +++++++++++++++++------------------ 7 files changed, 91 insertions(+), 83 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 50f8304f9b3..008eeed40d6 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -440,11 +440,11 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, const struct anv_color_attachment_view *cview = (const struct anv_color_attachment_view *) aview; - const struct anv_surface_view *sview = &cview->surface_view; + const struct anv_image_view *iview = &cview->image_view; - bt_map[a] = sview->surface_state.offset + state_offset; - add_surface_state_reloc(cmd_buffer, sview->surface_state, - sview->bo, sview->offset); + bt_map[a] = iview->surface_state.offset + state_offset; + add_surface_state_reloc(cmd_buffer, iview->surface_state, + iview->bo, iview->offset); } if (layout == NULL) @@ -462,14 +462,28 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, struct anv_descriptor *desc = &d->set->descriptors[surface_slots[b].index]; - if (desc->type != ANV_DESCRIPTOR_TYPE_SURFACE_VIEW) + const struct anv_state *surface_state; + struct anv_bo *bo; + uint32_t bo_offset; + + switch (desc->type) { + case ANV_DESCRIPTOR_TYPE_EMPTY: + case ANV_DESCRIPTOR_TYPE_SAMPLER: continue; + case ANV_DESCRIPTOR_TYPE_BUFFER_VIEW: + surface_state = &desc->buffer_view->surface_state; + bo = desc->buffer_view->bo; + bo_offset = desc->buffer_view->offset; + break; + case ANV_DESCRIPTOR_TYPE_IMAGE_VIEW: + surface_state = &desc->image_view->surface_state; + bo = desc->image_view->bo; + bo_offset = desc->image_view->offset; + break; + } - const struct anv_surface_view *sview = desc->surface_view; - - bt_map[start + b] = sview->surface_state.offset + state_offset; - add_surface_state_reloc(cmd_buffer, sview->surface_state, - sview->bo, sview->offset); + bt_map[start + b] = surface_state->offset + state_offset; + add_surface_state_reloc(cmd_buffer, *surface_state, bo, bo_offset); } } diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index b2c8027fcf9..5302ee5cd73 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1408,7 +1408,7 @@ anv_buffer_view_create( if (bview == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - bview->surface_view = (struct anv_surface_view) { + *bview = (struct anv_buffer_view) { .bo = buffer->bo, .offset = buffer->offset + pCreateInfo->offset, .surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64), @@ -1428,7 +1428,7 @@ VkResult anv_DestroyBufferView( ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_buffer_view, bview, _bview); - anv_surface_view_fini(device, &bview->surface_view); + anv_state_pool_free(&device->surface_state_pool, bview->surface_state); anv_device_free(device, bview); return VK_SUCCESS; @@ -1754,8 +1754,8 @@ VkResult anv_UpdateDescriptorSets( write->pDescriptors[j].imageView); set->descriptors[write->destBinding + j] = (struct anv_descriptor) { - .type = ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, - .surface_view = &iview->surface_view, + .type = ANV_DESCRIPTOR_TYPE_IMAGE_VIEW, + .image_view = iview, }; } break; @@ -1778,8 +1778,8 @@ VkResult anv_UpdateDescriptorSets( write->pDescriptors[j].bufferView); set->descriptors[write->destBinding + j] = (struct anv_descriptor) { - .type = ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, - .surface_view = &bview->surface_view, + .type = ANV_DESCRIPTOR_TYPE_BUFFER_VIEW, + .buffer_view = bview, }; } diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 19004320298..75233d1fe61 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -372,13 +372,6 @@ VkResult anv_GetImageSubresourceLayout( stub_return(VK_UNSUPPORTED); } -void -anv_surface_view_fini(struct anv_device *device, - struct anv_surface_view *sview) -{ - anv_state_pool_free(&device->surface_state_pool, sview->surface_state); -} - VkResult anv_validate_CreateImageView(VkDevice _device, const VkImageViewCreateInfo *pCreateInfo, @@ -499,13 +492,20 @@ anv_CreateImageView(VkDevice _device, return VK_SUCCESS; } +static void +anv_image_view_fini(struct anv_device *device, + struct anv_image_view *iview) +{ + anv_state_pool_free(&device->surface_state_pool, iview->surface_state); +} + VkResult anv_DestroyImageView(VkDevice _device, VkImageView _iview) { ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_image_view, iview, _iview); - anv_surface_view_fini(device, &iview->surface_view); + anv_image_view_fini(device, iview); anv_device_free(device, iview); return VK_SUCCESS; @@ -643,7 +643,7 @@ anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) struct anv_color_attachment_view *cview = (struct anv_color_attachment_view *) aview; - anv_surface_view_fini(device, &cview->surface_view); + anv_image_view_fini(device, &cview->image_view); } anv_device_free(device, aview); diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index fe235e23fb0..1574830e0b8 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -739,7 +739,7 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, { struct anv_device *device = cmd_buffer->device; struct anv_attachment_view *dest_aview = &dest_cview->attachment_view; - struct anv_surface_view *dest_sview = &dest_cview->surface_view; + struct anv_image_view *dest_iview = &dest_cview->image_view; VkDescriptorPool dummy_desc_pool = { .handle = 1 }; struct blit_vb_data { @@ -854,7 +854,7 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .attachmentCount = 1, .pAttachments = &(VkAttachmentDescription) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, - .format = dest_sview->format->vk_format, + .format = dest_iview->format->vk_format, .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, .storeOp = VK_ATTACHMENT_STORE_OP_STORE, .initialLayout = VK_IMAGE_LAYOUT_GENERAL, @@ -1561,7 +1561,7 @@ void anv_CmdClearColorImage( cmd_buffer); struct anv_attachment_view *aview = &cview.attachment_view; - struct anv_surface_view *sview = &cview.surface_view; + struct anv_image_view *iview = &cview.image_view; VkFramebuffer fb; anv_CreateFramebuffer(anv_device_to_handle(cmd_buffer->device), @@ -1586,7 +1586,7 @@ void anv_CmdClearColorImage( .attachmentCount = 1, .pAttachments = &(VkAttachmentDescription) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, - .format = sview->format->vk_format, + .format = iview->format->vk_format, .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, .storeOp = VK_ATTACHMENT_STORE_OP_STORE, .initialLayout = VK_IMAGE_LAYOUT_GENERAL, diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 09890730fd6..8c4c9efdc6f 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -730,14 +730,16 @@ struct anv_descriptor_set_layout { enum anv_descriptor_type { ANV_DESCRIPTOR_TYPE_EMPTY = 0, + ANV_DESCRIPTOR_TYPE_BUFFER_VIEW, + ANV_DESCRIPTOR_TYPE_IMAGE_VIEW, ANV_DESCRIPTOR_TYPE_SAMPLER, - ANV_DESCRIPTOR_TYPE_SURFACE_VIEW, }; struct anv_descriptor { union { + struct anv_buffer_view *buffer_view; + struct anv_image_view *image_view; struct anv_sampler *sampler; - struct anv_surface_view *surface_view; }; enum anv_descriptor_type type; @@ -1233,20 +1235,19 @@ struct anv_image { }; }; -struct anv_surface_view { +struct anv_buffer_view { struct anv_state surface_state; /**< RENDER_SURFACE_STATE */ struct anv_bo *bo; - uint32_t offset; /**< VkBufferCreateInfo::offset */ - uint32_t range; /**< VkBufferCreateInfo::range */ - const struct anv_format *format; /**< VkBufferCreateInfo::format */ -}; - -struct anv_buffer_view { - struct anv_surface_view surface_view; + uint32_t offset; /**< Offset into bo. */ + uint32_t range; /**< VkBufferViewCreateInfo::range */ + const struct anv_format *format; /**< VkBufferViewCreateInfo::format */ }; struct anv_image_view { - struct anv_surface_view surface_view; + struct anv_state surface_state; /**< RENDER_SURFACE_STATE */ + struct anv_bo *bo; + uint32_t offset; /**< Offset into bo. */ + const struct anv_format *format; /**< VkImageViewCreateInfo::format */ VkExtent3D extent; }; @@ -1262,7 +1263,7 @@ struct anv_attachment_view { struct anv_color_attachment_view { struct anv_attachment_view attachment_view; - struct anv_surface_view surface_view; + struct anv_image_view image_view; }; struct anv_depth_stencil_view { @@ -1334,9 +1335,6 @@ void gen7_fill_buffer_surface_state(void *state, const struct anv_format *format void gen8_fill_buffer_surface_state(void *state, const struct anv_format *format, uint32_t offset, uint32_t range); -void anv_surface_view_fini(struct anv_device *device, - struct anv_surface_view *sview); - struct anv_sampler { uint32_t state[4]; }; diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index a782690718b..5031db5edea 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -75,9 +75,8 @@ VkResult gen7_CreateBufferView( const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); - gen7_fill_buffer_surface_state(bview->surface_view.surface_state.map, - format, bview->surface_view.offset, - pCreateInfo->range); + gen7_fill_buffer_surface_state(bview->surface_state.map, format, + bview->offset, pCreateInfo->range); *pView = anv_buffer_view_to_handle(bview); @@ -273,7 +272,6 @@ gen7_image_view_init(struct anv_image_view *iview, ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; - struct anv_surface_view *sview = &iview->surface_view; struct anv_surface *surface = anv_image_get_surface_for_aspect_mask(image, range->aspectMask); @@ -286,9 +284,9 @@ gen7_image_view_init(struct anv_image_view *iview, if (pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D) anv_finishme("non-2D image views"); - sview->bo = image->bo; - sview->offset = image->offset + surface->offset; - sview->format = anv_format_for_vk_format(pCreateInfo->format); + iview->bo = image->bo; + iview->offset = image->offset + surface->offset; + iview->format = anv_format_for_vk_format(pCreateInfo->format); iview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, range->baseMipLevel), @@ -346,18 +344,18 @@ gen7_image_view_init(struct anv_image_view *iview, .BlueClearColor = 0, .AlphaClearColor = 0, .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, sview->offset }, + .SurfaceBaseAddress = { NULL, iview->offset }, }; if (cmd_buffer) { - sview->surface_state = + iview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - sview->surface_state = + iview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } - GEN7_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, &surface_state); } @@ -369,7 +367,7 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); struct anv_attachment_view *aview = &cview->attachment_view; - struct anv_surface_view *sview = &cview->surface_view; + struct anv_image_view *iview = &cview->image_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); @@ -379,9 +377,9 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); - sview->bo = image->bo; - sview->offset = image->offset + surface->offset; - sview->format = anv_format_for_vk_format(pCreateInfo->format); + iview->bo = image->bo; + iview->offset = image->offset + surface->offset; + iview->format = anv_format_for_vk_format(pCreateInfo->format); aview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), @@ -397,17 +395,17 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, } if (cmd_buffer) { - sview->surface_state = + iview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - sview->surface_state = + iview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } struct GEN7_RENDER_SURFACE_STATE surface_state = { .SurfaceType = SURFTYPE_2D, .SurfaceArray = image->array_size > 1, - .SurfaceFormat = sview->format->surface_format, + .SurfaceFormat = iview->format->surface_format, .SurfaceVerticalAlignment = anv_valign[surface->v_align], .SurfaceHorizontalAlignment = anv_halign[surface->h_align], @@ -447,10 +445,10 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, .BlueClearColor = 0, .AlphaClearColor = 0, .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, sview->offset }, + .SurfaceBaseAddress = { NULL, iview->offset }, }; - GEN7_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, &surface_state); } diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index c47d317d2a3..2b820a3177d 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -119,9 +119,8 @@ VkResult gen8_CreateBufferView( const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); - gen8_fill_buffer_surface_state(bview->surface_view.surface_state.map, - format, bview->surface_view.offset, - pCreateInfo->range); + gen8_fill_buffer_surface_state(bview->surface_state.map, format, + bview->offset, pCreateInfo->range); *pView = anv_buffer_view_to_handle(bview); @@ -149,7 +148,6 @@ gen8_image_view_init(struct anv_image_view *iview, ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; - struct anv_surface_view *sview = &iview->surface_view; struct anv_surface *surface = anv_image_get_surface_for_aspect_mask(image, range->aspectMask); @@ -162,9 +160,9 @@ gen8_image_view_init(struct anv_image_view *iview, const struct anv_image_view_info view_type_info = anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType); - sview->bo = image->bo; - sview->offset = image->offset + surface->offset; - sview->format = format_info; + iview->bo = image->bo; + iview->offset = image->offset + surface->offset; + iview->format = format_info; iview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, range->baseMipLevel), @@ -267,18 +265,18 @@ gen8_image_view_init(struct anv_image_view *iview, .ShaderChannelSelectBlue = vk_to_gen_swizzle[pCreateInfo->channels.b], .ShaderChannelSelectAlpha = vk_to_gen_swizzle[pCreateInfo->channels.a], .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, sview->offset }, + .SurfaceBaseAddress = { NULL, iview->offset }, }; if (cmd_buffer) { - sview->surface_state = + iview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - sview->surface_state = + iview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } - GEN8_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, &surface_state); } @@ -290,7 +288,7 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); struct anv_attachment_view *aview = &cview->attachment_view; - struct anv_surface_view *sview = &cview->surface_view; + struct anv_image_view *iview = &cview->image_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); const struct anv_format *format_info = @@ -305,9 +303,9 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); - sview->bo = image->bo; - sview->offset = image->offset + surface->offset; - sview->format = anv_format_for_vk_format(pCreateInfo->format); + iview->bo = image->bo; + iview->offset = image->offset + surface->offset; + iview->format = anv_format_for_vk_format(pCreateInfo->format); aview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), @@ -355,10 +353,10 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, } if (cmd_buffer) { - sview->surface_state = + iview->surface_state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); } else { - sview->surface_state = + iview->surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64); } @@ -411,10 +409,10 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, .ShaderChannelSelectBlue = SCS_BLUE, .ShaderChannelSelectAlpha = SCS_ALPHA, .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, sview->offset }, + .SurfaceBaseAddress = { NULL, iview->offset }, }; - GEN8_RENDER_SURFACE_STATE_pack(NULL, sview->surface_state.map, + GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, &surface_state); } From ae30535602d8b2f10a31feb133331c0c985b8b41 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 16:58:25 -0700 Subject: [PATCH 19/76] vk: Drop anv_attachment_view::extent It's duplicated by anv_attachment_view::image_view::extent. --- src/vulkan/anv_meta.c | 12 ++++++------ src/vulkan/anv_private.h | 1 - src/vulkan/gen7_state.c | 2 +- src/vulkan/gen8_state.c | 4 ++-- 4 files changed, 9 insertions(+), 10 deletions(-) diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 1574830e0b8..085acc7a318 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -842,8 +842,8 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .layout = VK_IMAGE_LAYOUT_GENERAL } }, - .width = dest_aview->extent.width, - .height = dest_aview->extent.height, + .width = dest_iview->extent.width, + .height = dest_iview->extent.height, .layers = 1 }, &fb); @@ -1574,8 +1574,8 @@ void anv_CmdClearColorImage( .layout = VK_IMAGE_LAYOUT_GENERAL } }, - .width = aview->extent.width, - .height = aview->extent.height, + .width = iview->extent.width, + .height = iview->extent.height, .layers = 1 }, &fb); @@ -1622,8 +1622,8 @@ void anv_CmdClearColorImage( .renderArea = { .offset = { 0, 0, }, .extent = { - .width = aview->extent.width, - .height = aview->extent.height, + .width = iview->extent.width, + .height = iview->extent.height, }, }, .renderPass = pass, diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 8c4c9efdc6f..b290fcc75b7 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1258,7 +1258,6 @@ enum anv_attachment_view_type { struct anv_attachment_view { enum anv_attachment_view_type attachment_type; - VkExtent3D extent; }; struct anv_color_attachment_view { diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 5031db5edea..d65c1a373f0 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -381,7 +381,7 @@ gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, iview->offset = image->offset + surface->offset; iview->format = anv_format_for_vk_format(pCreateInfo->format); - aview->extent = (VkExtent3D) { + iview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), .height = anv_minify(image->extent.height, pCreateInfo->mipLevel), .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel), diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 2b820a3177d..8e9b43cab05 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -307,7 +307,7 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, iview->offset = image->offset + surface->offset; iview->format = anv_format_for_vk_format(pCreateInfo->format); - aview->extent = (VkExtent3D) { + iview->extent = (VkExtent3D) { .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), .height = anv_minify(image->extent.height, pCreateInfo->mipLevel), .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel), @@ -346,7 +346,7 @@ gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, * indicates the extent of the accessible 'R' coordinates minus 1 on * the LOD currently being rendered to. */ - rt_view_extent = aview->extent.depth; + rt_view_extent = iview->extent.depth; break; default: unreachable(!"bad VkImageType"); From 935706234855e19e17402ee3b3cc19bc032b4932 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 17:27:38 -0700 Subject: [PATCH 20/76] vk: Merge anv_*_attachment_view into anv_attachment_view Remove anv_color_attachment_view and anv_depth_stencil_view, merging them into anv_attachment_view. This prepares for merging VkAttachmentView into VkImageView. --- src/vulkan/anv_cmd_buffer.c | 10 +++----- src/vulkan/anv_image.c | 50 ++++++++++++++---------------------- src/vulkan/anv_meta.c | 44 +++++++++++++++---------------- src/vulkan/anv_private.h | 21 +++++---------- src/vulkan/gen7_cmd_buffer.c | 13 +++++----- src/vulkan/gen7_state.c | 5 ++-- src/vulkan/gen8_cmd_buffer.c | 13 +++++----- src/vulkan/gen8_state.c | 5 ++-- 8 files changed, 67 insertions(+), 94 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 008eeed40d6..cab916c1383 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -434,14 +434,10 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, for (uint32_t a = 0; a < attachments; a++) { const struct anv_attachment_view *aview = fb->attachments[subpass->color_attachments[a]]; + const struct anv_image_view *iview = &aview->image_view; assert(aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR); - const struct anv_color_attachment_view *cview = - (const struct anv_color_attachment_view *) aview; - - const struct anv_image_view *iview = &cview->image_view; - bt_map[a] = iview->surface_state.offset + state_offset; add_surface_state_reloc(cmd_buffer, iview->surface_state, iview->bo, iview->offset); @@ -821,7 +817,7 @@ VkResult anv_ResetCommandPool( /** * Return NULL if the current subpass has no depthstencil attachment. */ -const struct anv_depth_stencil_view * +const struct anv_attachment_view * anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer) { const struct anv_subpass *subpass = cmd_buffer->state.subpass; @@ -835,5 +831,5 @@ anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer) assert(aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL); - return (const struct anv_depth_stencil_view *) aview; + return aview; } diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 75233d1fe61..f926cc2b1c0 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -512,24 +512,23 @@ anv_DestroyImageView(VkDevice _device, VkImageView _iview) } static void -anv_depth_stencil_view_init(struct anv_depth_stencil_view *ds_view, +anv_depth_stencil_view_init(struct anv_attachment_view *aview, const VkAttachmentViewCreateInfo *pCreateInfo) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - ds_view->attachment_view.attachment_type = - ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL; + aview->attachment_type = ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL; /* XXX: We don't handle any of these */ anv_assert(pCreateInfo->mipLevel == 0); anv_assert(pCreateInfo->baseArraySlice == 0); anv_assert(pCreateInfo->arraySize == 1); - ds_view->image = image; - ds_view->format = anv_format_for_vk_format(pCreateInfo->format); + aview->image_view.image = image; + aview->image_view.format = anv_format_for_vk_format(pCreateInfo->format); assert(anv_format_is_depth_or_stencil(image->format)); - assert(anv_format_is_depth_or_stencil(ds_view->format)); + assert(anv_format_is_depth_or_stencil(aview->image_view.format)); } struct anv_surface * @@ -579,17 +578,17 @@ anv_image_get_surface_for_color_attachment(struct anv_image *image) } void -anv_color_attachment_view_init(struct anv_color_attachment_view *cview, +anv_color_attachment_view_init(struct anv_attachment_view *aview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { switch (device->info.gen) { case 7: - gen7_color_attachment_view_init(cview, device, pCreateInfo, cmd_buffer); + gen7_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer); break; case 8: - gen8_color_attachment_view_init(cview, device, pCreateInfo, cmd_buffer); + gen8_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer); break; default: unreachable("unsupported gen\n"); @@ -602,34 +601,26 @@ anv_CreateAttachmentView(VkDevice _device, VkAttachmentView *pView) { ANV_FROM_HANDLE(anv_device, device, _device); + struct anv_attachment_view *aview; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO); + aview = anv_device_alloc(device, sizeof(*aview), 8, + VK_SYSTEM_ALLOC_TYPE_API_OBJECT); + if (aview == NULL) + return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); + const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); if (anv_format_is_depth_or_stencil(format)) { - struct anv_depth_stencil_view *ds_view = - anv_device_alloc(device, sizeof(*ds_view), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (ds_view == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - anv_depth_stencil_view_init(ds_view, pCreateInfo); - - *pView = anv_attachment_view_to_handle(&ds_view->attachment_view); + anv_depth_stencil_view_init(aview, pCreateInfo); } else { - struct anv_color_attachment_view *cview = - anv_device_alloc(device, sizeof(*cview), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (cview == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - anv_color_attachment_view_init(cview, device, pCreateInfo, NULL); - - *pView = anv_attachment_view_to_handle(&cview->attachment_view); + anv_color_attachment_view_init(aview, device, pCreateInfo, NULL); } + *pView = anv_attachment_view_to_handle(aview); + return VK_SUCCESS; } @@ -640,10 +631,7 @@ anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) ANV_FROM_HANDLE(anv_attachment_view, aview, _aview); if (aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR) { - struct anv_color_attachment_view *cview = - (struct anv_color_attachment_view *) aview; - - anv_image_view_fini(device, &cview->image_view); + anv_image_view_fini(device, &aview->image_view); } anv_device_free(device, aview); diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 085acc7a318..f6134338fdd 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -733,13 +733,12 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, VkOffset3D src_offset, VkExtent3D src_extent, struct anv_image *dest_image, - struct anv_color_attachment_view *dest_cview, + struct anv_attachment_view *dest_aview, VkOffset3D dest_offset, VkExtent3D dest_extent) { struct anv_device *device = cmd_buffer->device; - struct anv_attachment_view *dest_aview = &dest_cview->attachment_view; - struct anv_image_view *dest_iview = &dest_cview->image_view; + struct anv_image_view *dest_iview = &dest_aview->image_view; VkDescriptorPool dummy_desc_pool = { .handle = 1 }; struct blit_vb_data { @@ -1023,8 +1022,8 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, }, cmd_buffer); - struct anv_color_attachment_view dest_cview; - anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, + struct anv_attachment_view dest_aview; + anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = dest_image, @@ -1041,7 +1040,7 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, (VkOffset3D) { 0, 0, 0 }, (VkExtent3D) { width, height, 1 }, anv_image_from_handle(dest_image), - &dest_cview, + &dest_aview, (VkOffset3D) { 0, 0, 0 }, (VkExtent3D) { width, height, 1 }); @@ -1185,8 +1184,8 @@ void anv_CmdCopyImage( if (pRegions[r].extent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_color_attachment_view dest_cview; - anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, + struct anv_attachment_view dest_aview; + anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1201,7 +1200,7 @@ void anv_CmdCopyImage( src_image, &src_iview, pRegions[r].srcOffset, pRegions[r].extent, - dest_image, &dest_cview, + dest_image, &dest_aview, dest_offset, pRegions[r].extent); } @@ -1271,8 +1270,8 @@ void anv_CmdBlitImage( if (pRegions[r].destExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_color_attachment_view dest_cview; - anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, + struct anv_attachment_view dest_aview; + anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1287,7 +1286,7 @@ void anv_CmdBlitImage( src_image, &src_iview, pRegions[r].srcOffset, pRegions[r].srcExtent, - dest_image, &dest_cview, + dest_image, &dest_aview, dest_offset, pRegions[r].destExtent); } @@ -1401,8 +1400,8 @@ void anv_CmdCopyBufferToImage( if (pRegions[r].imageExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_color_attachment_view dest_cview; - anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, + struct anv_attachment_view dest_aview; + anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = anv_image_to_handle(dest_image), @@ -1419,7 +1418,7 @@ void anv_CmdCopyBufferToImage( (VkOffset3D) { 0, 0, 0 }, pRegions[r].imageExtent, dest_image, - &dest_cview, + &dest_aview, dest_offset, pRegions[r].imageExtent); @@ -1483,8 +1482,8 @@ void anv_CmdCopyImageToBuffer( dest_format, &pRegions[r]); - struct anv_color_attachment_view dest_cview; - anv_color_attachment_view_init(&dest_cview, cmd_buffer->device, + struct anv_attachment_view dest_aview; + anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1501,7 +1500,7 @@ void anv_CmdCopyImageToBuffer( pRegions[r].imageOffset, pRegions[r].imageExtent, anv_image_from_handle(destImage), - &dest_cview, + &dest_aview, (VkOffset3D) { 0, 0, 0 }, pRegions[r].imageExtent); @@ -1548,8 +1547,8 @@ void anv_CmdClearColorImage( for (uint32_t r = 0; r < rangeCount; r++) { for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { for (uint32_t s = 0; s < pRanges[r].arraySize; s++) { - struct anv_color_attachment_view cview; - anv_color_attachment_view_init(&cview, cmd_buffer->device, + struct anv_attachment_view aview; + anv_color_attachment_view_init(&aview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = _image, @@ -1560,8 +1559,7 @@ void anv_CmdClearColorImage( }, cmd_buffer); - struct anv_attachment_view *aview = &cview.attachment_view; - struct anv_image_view *iview = &cview.image_view; + struct anv_image_view *iview = &aview.image_view; VkFramebuffer fb; anv_CreateFramebuffer(anv_device_to_handle(cmd_buffer->device), @@ -1570,7 +1568,7 @@ void anv_CmdClearColorImage( .attachmentCount = 1, .pAttachments = (VkAttachmentBindInfo[]) { { - .view = anv_attachment_view_to_handle(aview), + .view = anv_attachment_view_to_handle(&aview), .layout = VK_IMAGE_LAYOUT_GENERAL } }, diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index b290fcc75b7..a0d4f8c2867 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -994,7 +994,7 @@ anv_cmd_buffer_push_constants(struct anv_cmd_buffer *cmd_buffer, void anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer, struct anv_render_pass *pass, const VkClearValue *clear_values); -const struct anv_depth_stencil_view * +const struct anv_attachment_view * anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer); void anv_cmd_buffer_dump(struct anv_cmd_buffer *cmd_buffer); @@ -1244,10 +1244,11 @@ struct anv_buffer_view { }; struct anv_image_view { + const struct anv_image *image; /**< VkAttachmentViewCreateInfo::image */ + const struct anv_format *format; /**< VkAttachmentViewCreateInfo::format */ struct anv_state surface_state; /**< RENDER_SURFACE_STATE */ struct anv_bo *bo; uint32_t offset; /**< Offset into bo. */ - const struct anv_format *format; /**< VkImageViewCreateInfo::format */ VkExtent3D extent; }; @@ -1258,19 +1259,9 @@ enum anv_attachment_view_type { struct anv_attachment_view { enum anv_attachment_view_type attachment_type; -}; - -struct anv_color_attachment_view { - struct anv_attachment_view attachment_view; struct anv_image_view image_view; }; -struct anv_depth_stencil_view { - struct anv_attachment_view attachment_view; - const struct anv_image *image; /**< VkAttachmentViewCreateInfo::image */ - const struct anv_format *format; /**< VkAttachmentViewCreateInfo::format */ -}; - struct anv_image_create_info { const VkImageCreateInfo *vk_info; bool force_tile_mode; @@ -1306,17 +1297,17 @@ gen8_image_view_init(struct anv_image_view *iview, const VkImageViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void anv_color_attachment_view_init(struct anv_color_attachment_view *cview, +void anv_color_attachment_view_init(struct anv_attachment_view *aview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, +void gen7_color_attachment_view_init(struct anv_attachment_view *aview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, +void gen8_color_attachment_view_init(struct anv_attachment_view *aview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index b264013d62e..5803569502f 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -529,20 +529,21 @@ static void gen7_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) { const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; - const struct anv_depth_stencil_view *ds_view = + const struct anv_attachment_view *aview = anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); - const struct anv_image *image = ds_view ? ds_view->image : NULL; - const bool has_depth = ds_view && ds_view->format->depth_format; - const bool has_stencil = ds_view && ds_view->format->has_stencil; + const struct anv_image_view *iview = aview ? &aview->image_view : NULL; + const struct anv_image *image = iview ? iview->image : NULL; + const bool has_depth = iview && iview->format->depth_format; + const bool has_stencil = iview && iview->format->has_stencil; /* Emit 3DSTATE_DEPTH_BUFFER */ if (has_depth) { anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_DEPTH_BUFFER, .SurfaceType = SURFTYPE_2D, - .DepthWriteEnable = ds_view->format->depth_format, + .DepthWriteEnable = iview->format->depth_format, .StencilWriteEnable = has_stencil, .HierarchicalDepthBufferEnable = false, - .SurfaceFormat = ds_view->format->depth_format, + .SurfaceFormat = iview->format->depth_format, .SurfacePitch = image->depth_surface.stride - 1, .SurfaceBaseAddress = { .bo = image->bo, diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index d65c1a373f0..778c9096461 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -360,14 +360,13 @@ gen7_image_view_init(struct anv_image_view *iview, } void -gen7_color_attachment_view_init(struct anv_color_attachment_view *cview, +gen7_color_attachment_view_init(struct anv_attachment_view *aview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_attachment_view *aview = &cview->attachment_view; - struct anv_image_view *iview = &cview->image_view; + struct anv_image_view *iview = &aview->image_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index 30573639986..3ed32e8de3d 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -458,11 +458,12 @@ static void gen8_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) { const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; - const struct anv_depth_stencil_view *ds_view = + const struct anv_attachment_view *aview = anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); - const struct anv_image *image = ds_view ? ds_view->image : NULL; - const bool has_depth = ds_view && ds_view->format->depth_format; - const bool has_stencil = ds_view && ds_view->format->has_stencil; + const struct anv_image_view *iview = aview ? &aview->image_view : NULL; + const struct anv_image *image = iview ? iview->image : NULL; + const bool has_depth = iview && iview->format->depth_format; + const bool has_stencil = iview && iview->format->has_stencil; /* FIXME: Implement the PMA stall W/A */ /* FIXME: Width and Height are wrong */ @@ -471,10 +472,10 @@ gen8_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) if (has_depth) { anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DEPTH_BUFFER, .SurfaceType = SURFTYPE_2D, - .DepthWriteEnable = ds_view->format->depth_format, + .DepthWriteEnable = iview->format->depth_format, .StencilWriteEnable = has_stencil, .HierarchicalDepthBufferEnable = false, - .SurfaceFormat = ds_view->format->depth_format, + .SurfaceFormat = iview->format->depth_format, .SurfacePitch = image->depth_surface.stride - 1, .SurfaceBaseAddress = { .bo = image->bo, diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 8e9b43cab05..450bc52b579 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -281,14 +281,13 @@ gen8_image_view_init(struct anv_image_view *iview, } void -gen8_color_attachment_view_init(struct anv_color_attachment_view *cview, +gen8_color_attachment_view_init(struct anv_attachment_view *aview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_attachment_view *aview = &cview->attachment_view; - struct anv_image_view *iview = &cview->image_view; + struct anv_image_view *iview = &aview->image_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); const struct anv_format *format_info = From 39a19e88a3e0b5ded30c27b61b85d09f605af8f6 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:06:05 -0700 Subject: [PATCH 21/76] vulkan.h: Various cosmetic changes These don't affect the driver in any way. --- include/vulkan/vulkan.h | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 44d5fe0e3e3..97902309020 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -878,11 +878,6 @@ typedef enum { VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, } VkMemoryHeapFlagBits; typedef VkFlags VkMemoryHeapFlags; - -typedef enum { - VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, -} VkDeviceCreateFlagBits; -typedef VkFlags VkDeviceCreateFlags; typedef VkFlags VkMemoryMapFlags; typedef enum { @@ -1080,16 +1075,6 @@ typedef enum { } VkQueryControlFlagBits; typedef VkFlags VkQueryControlFlags; -typedef struct { - VkStructureType sType; - const void* pNext; - const char* pAppName; - uint32_t appVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - typedef void* (VKAPI *PFN_vkAllocFunction)( void* pUserData, size_t size, @@ -1100,6 +1085,18 @@ typedef void (VKAPI *PFN_vkFreeFunction)( void* pUserData, void* pMem); +typedef void (VKAPI *PFN_vkVoidFunction)(void); + +typedef struct { + VkStructureType sType; + const void* pNext; + const char* pAppName; + uint32_t appVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + typedef struct { void* pUserData; PFN_vkAllocFunction pfnAlloc; @@ -1316,8 +1313,9 @@ typedef struct { VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; } VkPhysicalDeviceMemoryProperties; -typedef void (VKAPI *PFN_vkVoidFunction)(void); typedef struct { + VkStructureType sType; + const void* pNext; uint32_t queueFamilyIndex; uint32_t queueCount; } VkDeviceQueueCreateInfo; @@ -1332,7 +1330,6 @@ typedef struct { uint32_t extensionCount; const char*const* ppEnabledExtensionNames; const VkPhysicalDeviceFeatures* pEnabledFeatures; - VkDeviceCreateFlags flags; } VkDeviceCreateInfo; typedef struct { From f7c3519aaf12d2e3878becd965433c9970383d84 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:15:06 -0700 Subject: [PATCH 22/76] vk/0.170.2: Rename VkTexAddress to VkTexAddressMode --- include/vulkan/vulkan.h | 24 ++++++++++++------------ src/vulkan/gen7_state.c | 16 ++++++++-------- src/vulkan/gen8_state.c | 16 ++++++++-------- 3 files changed, 28 insertions(+), 28 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 97902309020..a13ff990020 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -688,16 +688,16 @@ typedef enum { } VkTexMipmapMode; typedef enum { - VK_TEX_ADDRESS_WRAP = 0, - VK_TEX_ADDRESS_MIRROR = 1, - VK_TEX_ADDRESS_CLAMP = 2, - VK_TEX_ADDRESS_MIRROR_ONCE = 3, - VK_TEX_ADDRESS_CLAMP_BORDER = 4, - VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, - VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, - VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1), + VK_TEX_ADDRESS_MODE_WRAP = 0, + VK_TEX_ADDRESS_MODE_MIRROR = 1, + VK_TEX_ADDRESS_MODE_CLAMP = 2, + VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3, + VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4, + VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP, + VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER, + VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1), VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF -} VkTexAddress; +} VkTexAddressMode; typedef enum { VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, @@ -1717,9 +1717,9 @@ typedef struct { VkTexFilter magFilter; VkTexFilter minFilter; VkTexMipmapMode mipMode; - VkTexAddress addressU; - VkTexAddress addressV; - VkTexAddress addressW; + VkTexAddressMode addressModeU; + VkTexAddressMode addressModeV; + VkTexAddressMode addressModeW; float mipLodBias; float maxAnisotropy; VkBool32 compareEnable; diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 778c9096461..a06e76015d3 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -95,11 +95,11 @@ static const uint32_t vk_to_gen_mipmap_mode[] = { }; static const uint32_t vk_to_gen_tex_address[] = { - [VK_TEX_ADDRESS_WRAP] = TCM_WRAP, - [VK_TEX_ADDRESS_MIRROR] = TCM_MIRROR, - [VK_TEX_ADDRESS_CLAMP] = TCM_CLAMP, - [VK_TEX_ADDRESS_MIRROR_ONCE] = TCM_MIRROR_ONCE, - [VK_TEX_ADDRESS_CLAMP_BORDER] = TCM_CLAMP_BORDER, + [VK_TEX_ADDRESS_MODE_WRAP] = TCM_WRAP, + [VK_TEX_ADDRESS_MODE_MIRROR] = TCM_MIRROR, + [VK_TEX_ADDRESS_MODE_CLAMP] = TCM_CLAMP, + [VK_TEX_ADDRESS_MODE_MIRROR_ONCE] = TCM_MIRROR_ONCE, + [VK_TEX_ADDRESS_MODE_CLAMP_BORDER] = TCM_CLAMP_BORDER, }; static const uint32_t vk_to_gen_compare_op[] = { @@ -169,9 +169,9 @@ VkResult gen7_CreateSampler( .UAddressMagFilterRoundingEnable = 0, .TrilinearFilterQuality = 0, .NonnormalizedCoordinateEnable = 0, - .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressU], - .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressV], - .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressW], + .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeU], + .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeV], + .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeW], }; GEN7_SAMPLER_STATE_pack(NULL, sampler->state, &sampler_state); diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 450bc52b579..60135feaebe 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -443,11 +443,11 @@ VkResult gen8_CreateSampler( }; static const uint32_t vk_to_gen_tex_address[] = { - [VK_TEX_ADDRESS_WRAP] = TCM_WRAP, - [VK_TEX_ADDRESS_MIRROR] = TCM_MIRROR, - [VK_TEX_ADDRESS_CLAMP] = TCM_CLAMP, - [VK_TEX_ADDRESS_MIRROR_ONCE] = TCM_MIRROR_ONCE, - [VK_TEX_ADDRESS_CLAMP_BORDER] = TCM_CLAMP_BORDER, + [VK_TEX_ADDRESS_MODE_WRAP] = TCM_WRAP, + [VK_TEX_ADDRESS_MODE_MIRROR] = TCM_MIRROR, + [VK_TEX_ADDRESS_MODE_CLAMP] = TCM_CLAMP, + [VK_TEX_ADDRESS_MODE_MIRROR_ONCE] = TCM_MIRROR_ONCE, + [VK_TEX_ADDRESS_MODE_CLAMP_BORDER] = TCM_CLAMP_BORDER, }; static const uint32_t vk_to_gen_compare_op[] = { @@ -503,9 +503,9 @@ VkResult gen8_CreateSampler( .UAddressMagFilterRoundingEnable = 0, .TrilinearFilterQuality = 0, .NonnormalizedCoordinateEnable = 0, - .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressU], - .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressV], - .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressW], + .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeU], + .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeV], + .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeW], }; GEN8_SAMPLER_STATE_pack(NULL, sampler->state, &sampler_state); From 57f500324b8d7b6de1e3d5e0c0b18622b97ecca9 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:17:24 -0700 Subject: [PATCH 23/76] vk/0.170.2: Add unnormalizedCoordinates to VkSamplerCreateInfo --- include/vulkan/vulkan.h | 1 + src/vulkan/gen7_state.c | 2 +- src/vulkan/gen8_state.c | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index a13ff990020..2afe53b6c9d 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1727,6 +1727,7 @@ typedef struct { float minLod; float maxLod; VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; } VkSamplerCreateInfo; typedef struct { diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index a06e76015d3..ed9d9f8c568 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -168,7 +168,7 @@ VkResult gen7_CreateSampler( .UAddressMinFilterRoundingEnable = 0, .UAddressMagFilterRoundingEnable = 0, .TrilinearFilterQuality = 0, - .NonnormalizedCoordinateEnable = 0, + .NonnormalizedCoordinateEnable = pCreateInfo->unnormalizedCoordinates, .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeU], .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeV], .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeW], diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 60135feaebe..4990becf60a 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -502,7 +502,7 @@ VkResult gen8_CreateSampler( .UAddressMinFilterRoundingEnable = 0, .UAddressMagFilterRoundingEnable = 0, .TrilinearFilterQuality = 0, - .NonnormalizedCoordinateEnable = 0, + .NonnormalizedCoordinateEnable = pCreateInfo->unnormalizedCoordinates, .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeU], .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeV], .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressModeW], From 757166592e5e26dc226849f94d1460db28a35170 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:26:21 -0700 Subject: [PATCH 24/76] vk/0.170.2: Rename pointer parameters of VkSubpassDescription --- include/vulkan/vulkan.h | 8 ++++---- src/vulkan/anv_device.c | 8 ++++---- src/vulkan/anv_meta.c | 12 ++++++------ 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 2afe53b6c9d..25d0f829f77 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1885,13 +1885,13 @@ typedef struct { VkPipelineBindPoint pipelineBindPoint; VkSubpassDescriptionFlags flags; uint32_t inputCount; - const VkAttachmentReference* inputAttachments; + const VkAttachmentReference* pInputAttachments; uint32_t colorCount; - const VkAttachmentReference* colorAttachments; - const VkAttachmentReference* resolveAttachments; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; VkAttachmentReference depthStencilAttachment; uint32_t preserveCount; - const VkAttachmentReference* preserveAttachments; + const VkAttachmentReference* pPreserveAttachments; } VkSubpassDescription; typedef struct { diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 5302ee5cd73..fdc6f8e1034 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -2117,7 +2117,7 @@ VkResult anv_CreateRenderPass( for (uint32_t j = 0; j < desc->inputCount; j++) { subpass->input_attachments[j] - = desc->inputAttachments[j].attachment; + = desc->pInputAttachments[j].attachment; } } @@ -2128,18 +2128,18 @@ VkResult anv_CreateRenderPass( for (uint32_t j = 0; j < desc->colorCount; j++) { subpass->color_attachments[j] - = desc->colorAttachments[j].attachment; + = desc->pColorAttachments[j].attachment; } } - if (desc->resolveAttachments) { + if (desc->pResolveAttachments) { subpass->resolve_attachments = anv_device_alloc(device, desc->colorCount * sizeof(uint32_t), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); for (uint32_t j = 0; j < desc->colorCount; j++) { subpass->resolve_attachments[j] - = desc->resolveAttachments[j].attachment; + = desc->pResolveAttachments[j].attachment; } } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index f6134338fdd..9201167bd98 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -865,17 +865,17 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, .inputCount = 0, .colorCount = 1, - .colorAttachments = &(VkAttachmentReference) { + .pColorAttachments = &(VkAttachmentReference) { .attachment = 0, .layout = VK_IMAGE_LAYOUT_GENERAL, }, - .resolveAttachments = NULL, + .pResolveAttachments = NULL, .depthStencilAttachment = (VkAttachmentReference) { .attachment = VK_ATTACHMENT_UNUSED, .layout = VK_IMAGE_LAYOUT_GENERAL, }, .preserveCount = 1, - .preserveAttachments = &(VkAttachmentReference) { + .pPreserveAttachments = &(VkAttachmentReference) { .attachment = 0, .layout = VK_IMAGE_LAYOUT_GENERAL, }, @@ -1596,17 +1596,17 @@ void anv_CmdClearColorImage( .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS, .inputCount = 0, .colorCount = 1, - .colorAttachments = &(VkAttachmentReference) { + .pColorAttachments = &(VkAttachmentReference) { .attachment = 0, .layout = VK_IMAGE_LAYOUT_GENERAL, }, - .resolveAttachments = NULL, + .pResolveAttachments = NULL, .depthStencilAttachment = (VkAttachmentReference) { .attachment = VK_ATTACHMENT_UNUSED, .layout = VK_IMAGE_LAYOUT_GENERAL, }, .preserveCount = 1, - .preserveAttachments = &(VkAttachmentReference) { + .pPreserveAttachments = &(VkAttachmentReference) { .attachment = 0, .layout = VK_IMAGE_LAYOUT_GENERAL, }, From 8e1ef639b6af17cfde2234fb2bd60c9c45cf265b Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:30:53 -0700 Subject: [PATCH 25/76] vk/0.170.2: Add the subpass field to VkCmdBufferBeginInfo --- include/vulkan/vulkan.h | 1 + src/vulkan/anv_cmd_buffer.c | 7 ++++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 25d0f829f77..48c4d195b2d 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1937,6 +1937,7 @@ typedef struct { const void* pNext; VkCmdBufferOptimizeFlags flags; VkRenderPass renderPass; + uint32_t subpass; VkFramebuffer framebuffer; } VkCmdBufferBeginInfo; diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index cab916c1383..eb70abfeb76 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -202,9 +202,10 @@ VkResult anv_BeginCommandBuffer( cmd_buffer->state.pass = anv_render_pass_from_handle(pBeginInfo->renderPass); - /* FIXME: We shouldn't be starting on the first subpass */ - anv_cmd_buffer_begin_subpass(cmd_buffer, - &cmd_buffer->state.pass->subpasses[0]); + struct anv_subpass *subpass = + &cmd_buffer->state.pass->subpasses[pBeginInfo->subpass]; + + anv_cmd_buffer_begin_subpass(cmd_buffer, subpass); } anv_cmd_buffer_emit_state_base_address(cmd_buffer); From 460676122fffddb26ef324293fcb5efb566796db Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:35:08 -0700 Subject: [PATCH 26/76] vk/0.170.2: Rename VkClearValue.ds to depthStencil --- include/vulkan/vulkan.h | 2 +- src/vulkan/anv_meta.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 48c4d195b2d..5deb161274f 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1999,7 +1999,7 @@ typedef struct { typedef union { VkClearColorValue color; - VkClearDepthStencilValue ds; + VkClearDepthStencilValue depthStencil; } VkClearValue; typedef struct { diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 9201167bd98..949e5a16601 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -458,7 +458,7 @@ anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer, } else if (att->format->depth_format) { assert(ds_attachment == VK_ATTACHMENT_UNUSED); ds_attachment = i; - ds_clear_value= clear_values[ds_attachment].ds; + ds_clear_value = clear_values[ds_attachment].depthStencil; } } else if (att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { assert(att->format->has_stencil); From 05a26a60c831f1dafc60a9f88b0d5cb2ca303d01 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 20:50:51 -0700 Subject: [PATCH 27/76] vk/0.170.2: Make destructors return void --- include/vulkan/vulkan.h | 116 ++++++++++++++++++------------------ src/vulkan/anv_cmd_buffer.c | 8 +-- src/vulkan/anv_device.c | 71 +++++++--------------- src/vulkan/anv_image.c | 12 +--- src/vulkan/anv_pipeline.c | 20 ++----- src/vulkan/anv_query.c | 4 +- 6 files changed, 89 insertions(+), 142 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 5deb161274f..9962cc17179 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2067,7 +2067,7 @@ typedef struct { typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); -typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); +typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); @@ -2080,7 +2080,7 @@ typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevi typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); -typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); +typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device); typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); @@ -2090,9 +2090,9 @@ typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCou typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); +typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); +typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); @@ -2106,75 +2106,75 @@ typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuf typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); -typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); +typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); -typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); +typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); +typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); +typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); -typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); +typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); -typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); +typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); +typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); -typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); +typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView); -typedef VkResult (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView); +typedef void (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView); typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); -typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); +typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); +typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); -typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); +typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); +typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); -typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); +typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); -typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); +typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); -typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); +typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); +typedef void (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); +typedef void (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); +typedef void (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef void (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); -typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); +typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); -typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); +typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); -typedef VkResult (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); +typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); -typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); +typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); @@ -2224,7 +2224,7 @@ VkResult VKAPI vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); -VkResult VKAPI vkDestroyInstance( +void VKAPI vkDestroyInstance( VkInstance instance); VkResult VKAPI vkEnumeratePhysicalDevices( @@ -2283,7 +2283,7 @@ VkResult VKAPI vkCreateDevice( const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); -VkResult VKAPI vkDestroyDevice( +void VKAPI vkDestroyDevice( VkDevice device); VkResult VKAPI vkGetGlobalExtensionProperties( @@ -2329,7 +2329,7 @@ VkResult VKAPI vkAllocMemory( const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -VkResult VKAPI vkFreeMemory( +void VKAPI vkFreeMemory( VkDevice device, VkDeviceMemory mem); @@ -2341,7 +2341,7 @@ VkResult VKAPI vkMapMemory( VkMemoryMapFlags flags, void** ppData); -VkResult VKAPI vkUnmapMemory( +void VKAPI vkUnmapMemory( VkDevice device, VkDeviceMemory mem); @@ -2421,7 +2421,7 @@ VkResult VKAPI vkCreateFence( const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); -VkResult VKAPI vkDestroyFence( +void VKAPI vkDestroyFence( VkDevice device, VkFence fence); @@ -2446,7 +2446,7 @@ VkResult VKAPI vkCreateSemaphore( const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); -VkResult VKAPI vkDestroySemaphore( +void VKAPI vkDestroySemaphore( VkDevice device, VkSemaphore semaphore); @@ -2463,7 +2463,7 @@ VkResult VKAPI vkCreateEvent( const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -VkResult VKAPI vkDestroyEvent( +void VKAPI vkDestroyEvent( VkDevice device, VkEvent event); @@ -2484,7 +2484,7 @@ VkResult VKAPI vkCreateQueryPool( const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -VkResult VKAPI vkDestroyQueryPool( +void VKAPI vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool); @@ -2502,7 +2502,7 @@ VkResult VKAPI vkCreateBuffer( const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); -VkResult VKAPI vkDestroyBuffer( +void VKAPI vkDestroyBuffer( VkDevice device, VkBuffer buffer); @@ -2511,7 +2511,7 @@ VkResult VKAPI vkCreateBufferView( const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); -VkResult VKAPI vkDestroyBufferView( +void VKAPI vkDestroyBufferView( VkDevice device, VkBufferView bufferView); @@ -2520,7 +2520,7 @@ VkResult VKAPI vkCreateImage( const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -VkResult VKAPI vkDestroyImage( +void VKAPI vkDestroyImage( VkDevice device, VkImage image); @@ -2535,7 +2535,7 @@ VkResult VKAPI vkCreateImageView( const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); -VkResult VKAPI vkDestroyImageView( +void VKAPI vkDestroyImageView( VkDevice device, VkImageView imageView); @@ -2544,7 +2544,7 @@ VkResult VKAPI vkCreateAttachmentView( const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView); -VkResult VKAPI vkDestroyAttachmentView( +void VKAPI vkDestroyAttachmentView( VkDevice device, VkAttachmentView attachmentView); @@ -2553,7 +2553,7 @@ VkResult VKAPI vkCreateShaderModule( const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); -VkResult VKAPI vkDestroyShaderModule( +void VKAPI vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule); @@ -2562,7 +2562,7 @@ VkResult VKAPI vkCreateShader( const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -VkResult VKAPI vkDestroyShader( +void VKAPI vkDestroyShader( VkDevice device, VkShader shader); @@ -2571,7 +2571,7 @@ VkResult VKAPI vkCreatePipelineCache( const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); -VkResult VKAPI vkDestroyPipelineCache( +void VKAPI vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache); @@ -2604,7 +2604,7 @@ VkResult VKAPI vkCreateComputePipelines( const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -VkResult VKAPI vkDestroyPipeline( +void VKAPI vkDestroyPipeline( VkDevice device, VkPipeline pipeline); @@ -2613,7 +2613,7 @@ VkResult VKAPI vkCreatePipelineLayout( const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); -VkResult VKAPI vkDestroyPipelineLayout( +void VKAPI vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout); @@ -2622,7 +2622,7 @@ VkResult VKAPI vkCreateSampler( const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); -VkResult VKAPI vkDestroySampler( +void VKAPI vkDestroySampler( VkDevice device, VkSampler sampler); @@ -2631,7 +2631,7 @@ VkResult VKAPI vkCreateDescriptorSetLayout( const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); -VkResult VKAPI vkDestroyDescriptorSetLayout( +void VKAPI vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout); @@ -2642,7 +2642,7 @@ VkResult VKAPI vkCreateDescriptorPool( const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -VkResult VKAPI vkDestroyDescriptorPool( +void VKAPI vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool); @@ -2677,7 +2677,7 @@ VkResult VKAPI vkCreateDynamicViewportState( const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); -VkResult VKAPI vkDestroyDynamicViewportState( +void VKAPI vkDestroyDynamicViewportState( VkDevice device, VkDynamicViewportState dynamicViewportState); @@ -2686,7 +2686,7 @@ VkResult VKAPI vkCreateDynamicRasterState( const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); -VkResult VKAPI vkDestroyDynamicRasterState( +void VKAPI vkDestroyDynamicRasterState( VkDevice device, VkDynamicRasterState dynamicRasterState); @@ -2695,7 +2695,7 @@ VkResult VKAPI vkCreateDynamicColorBlendState( const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); -VkResult VKAPI vkDestroyDynamicColorBlendState( +void VKAPI vkDestroyDynamicColorBlendState( VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); @@ -2704,7 +2704,7 @@ VkResult VKAPI vkCreateDynamicDepthStencilState( const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); -VkResult VKAPI vkDestroyDynamicDepthStencilState( +void VKAPI vkDestroyDynamicDepthStencilState( VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); @@ -2713,7 +2713,7 @@ VkResult VKAPI vkCreateFramebuffer( const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); -VkResult VKAPI vkDestroyFramebuffer( +void VKAPI vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer); @@ -2722,7 +2722,7 @@ VkResult VKAPI vkCreateRenderPass( const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); -VkResult VKAPI vkDestroyRenderPass( +void VKAPI vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass); @@ -2736,7 +2736,7 @@ VkResult VKAPI vkCreateCommandPool( const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); -VkResult VKAPI vkDestroyCommandPool( +void VKAPI vkDestroyCommandPool( VkDevice device, VkCmdPool cmdPool); @@ -2750,7 +2750,7 @@ VkResult VKAPI vkCreateCommandBuffer( const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); -VkResult VKAPI vkDestroyCommandBuffer( +void VKAPI vkDestroyCommandBuffer( VkDevice device, VkCmdBuffer commandBuffer); diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index eb70abfeb76..64f10ffe74e 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -144,7 +144,7 @@ VkResult anv_CreateCommandBuffer( return result; } -VkResult anv_DestroyCommandBuffer( +void anv_DestroyCommandBuffer( VkDevice _device, VkCmdBuffer _cmd_buffer) { @@ -158,8 +158,6 @@ VkResult anv_DestroyCommandBuffer( anv_state_stream_finish(&cmd_buffer->surface_state_stream); anv_state_stream_finish(&cmd_buffer->dynamic_state_stream); anv_device_free(device, cmd_buffer); - - return VK_SUCCESS; } VkResult anv_ResetCommandBuffer( @@ -786,7 +784,7 @@ VkResult anv_CreateCommandPool( return VK_SUCCESS; } -VkResult anv_DestroyCommandPool( +void anv_DestroyCommandPool( VkDevice _device, VkCmdPool cmdPool) { @@ -796,8 +794,6 @@ VkResult anv_DestroyCommandPool( anv_ResetCommandPool(_device, cmdPool, 0); anv_device_free(device, pool); - - return VK_SUCCESS; } VkResult anv_ResetCommandPool( diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index fdc6f8e1034..dd8e3ffa0af 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -178,7 +178,7 @@ VkResult anv_CreateInstance( return VK_SUCCESS; } -VkResult anv_DestroyInstance( +void anv_DestroyInstance( VkInstance _instance) { ANV_FROM_HANDLE(anv_instance, instance, _instance); @@ -190,8 +190,6 @@ VkResult anv_DestroyInstance( _mesa_locale_fini(); instance->pfnFree(instance->pAllocUserData, instance); - - return VK_SUCCESS; } void * @@ -650,7 +648,7 @@ VkResult anv_CreateDevice( return vk_error(VK_ERROR_UNAVAILABLE); } -VkResult anv_DestroyDevice( +void anv_DestroyDevice( VkDevice _device) { ANV_FROM_HANDLE(anv_device, device, _device); @@ -679,8 +677,6 @@ VkResult anv_DestroyDevice( close(device->fd); anv_instance_free(device->instance, device); - - return VK_SUCCESS; } VkResult anv_GetGlobalExtensionProperties( @@ -937,7 +933,7 @@ VkResult anv_AllocMemory( return result; } -VkResult anv_FreeMemory( +void anv_FreeMemory( VkDevice _device, VkDeviceMemory _mem) { @@ -951,8 +947,6 @@ VkResult anv_FreeMemory( anv_gem_close(device, mem->bo.gem_handle); anv_device_free(device, mem); - - return VK_SUCCESS; } VkResult anv_MapMemory( @@ -980,15 +974,13 @@ VkResult anv_MapMemory( return VK_SUCCESS; } -VkResult anv_UnmapMemory( +void anv_UnmapMemory( VkDevice _device, VkDeviceMemory _mem) { ANV_FROM_HANDLE(anv_device_memory, mem, _mem); anv_gem_munmap(mem->map, mem->map_size); - - return VK_SUCCESS; } VkResult anv_FlushMappedMemoryRanges( @@ -1195,7 +1187,7 @@ VkResult anv_CreateFence( return result; } -VkResult anv_DestroyFence( +void anv_DestroyFence( VkDevice _device, VkFence _fence) { @@ -1205,8 +1197,6 @@ VkResult anv_DestroyFence( anv_gem_munmap(fence->bo.map, fence->bo.size); anv_gem_close(device, fence->bo.gem_handle); anv_device_free(device, fence); - - return VK_SUCCESS; } VkResult anv_ResetFences( @@ -1278,11 +1268,11 @@ VkResult anv_CreateSemaphore( stub_return(VK_UNSUPPORTED); } -VkResult anv_DestroySemaphore( +void anv_DestroySemaphore( VkDevice device, VkSemaphore semaphore) { - stub_return(VK_UNSUPPORTED); + stub(); } VkResult anv_QueueSignalSemaphore( @@ -1309,11 +1299,11 @@ VkResult anv_CreateEvent( stub_return(VK_UNSUPPORTED); } -VkResult anv_DestroyEvent( +void anv_DestroyEvent( VkDevice device, VkEvent event) { - stub_return(VK_UNSUPPORTED); + stub(); } VkResult anv_GetEventStatus( @@ -1363,7 +1353,7 @@ VkResult anv_CreateBuffer( return VK_SUCCESS; } -VkResult anv_DestroyBuffer( +void anv_DestroyBuffer( VkDevice _device, VkBuffer _buffer) { @@ -1371,8 +1361,6 @@ VkResult anv_DestroyBuffer( ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); anv_device_free(device, buffer); - - return VK_SUCCESS; } void @@ -1421,7 +1409,7 @@ anv_buffer_view_create( return VK_SUCCESS; } -VkResult anv_DestroyBufferView( +void anv_DestroyBufferView( VkDevice _device, VkBufferView _bview) { @@ -1430,11 +1418,9 @@ VkResult anv_DestroyBufferView( anv_state_pool_free(&device->surface_state_pool, bview->surface_state); anv_device_free(device, bview); - - return VK_SUCCESS; } -VkResult anv_DestroySampler( +void anv_DestroySampler( VkDevice _device, VkSampler _sampler) { @@ -1442,8 +1428,6 @@ VkResult anv_DestroySampler( ANV_FROM_HANDLE(anv_sampler, sampler, _sampler); anv_device_free(device, sampler); - - return VK_SUCCESS; } // Descriptor set functions @@ -1601,7 +1585,7 @@ VkResult anv_CreateDescriptorSetLayout( return VK_SUCCESS; } -VkResult anv_DestroyDescriptorSetLayout( +void anv_DestroyDescriptorSetLayout( VkDevice _device, VkDescriptorSetLayout _set_layout) { @@ -1609,8 +1593,6 @@ VkResult anv_DestroyDescriptorSetLayout( ANV_FROM_HANDLE(anv_descriptor_set_layout, set_layout, _set_layout); anv_device_free(device, set_layout); - - return VK_SUCCESS; } VkResult anv_CreateDescriptorPool( @@ -1625,12 +1607,11 @@ VkResult anv_CreateDescriptorPool( return VK_SUCCESS; } -VkResult anv_DestroyDescriptorPool( +void anv_DestroyDescriptorPool( VkDevice _device, VkDescriptorPool _pool) { anv_finishme("VkDescriptorPool is a stub: free the pool's descriptor sets"); - return VK_SUCCESS; } VkResult anv_ResetDescriptorPool( @@ -1901,7 +1882,7 @@ VkResult anv_CreateDynamicViewportState( return VK_SUCCESS; } -VkResult anv_DestroyDynamicViewportState( +void anv_DestroyDynamicViewportState( VkDevice _device, VkDynamicViewportState _vp_state) { @@ -1913,11 +1894,9 @@ VkResult anv_DestroyDynamicViewportState( anv_state_pool_free(&device->dynamic_state_pool, vp_state->scissor); anv_device_free(device, vp_state); - - return VK_SUCCESS; } -VkResult anv_DestroyDynamicRasterState( +void anv_DestroyDynamicRasterState( VkDevice _device, VkDynamicRasterState _rs_state) { @@ -1925,8 +1904,6 @@ VkResult anv_DestroyDynamicRasterState( ANV_FROM_HANDLE(anv_dynamic_rs_state, rs_state, _rs_state); anv_device_free(device, rs_state); - - return VK_SUCCESS; } VkResult anv_CreateDynamicColorBlendState( @@ -1958,7 +1935,7 @@ VkResult anv_CreateDynamicColorBlendState( return VK_SUCCESS; } -VkResult anv_DestroyDynamicColorBlendState( +void anv_DestroyDynamicColorBlendState( VkDevice _device, VkDynamicColorBlendState _cb_state) { @@ -1966,11 +1943,9 @@ VkResult anv_DestroyDynamicColorBlendState( ANV_FROM_HANDLE(anv_dynamic_cb_state, cb_state, _cb_state); anv_device_free(device, cb_state); - - return VK_SUCCESS; } -VkResult anv_DestroyDynamicDepthStencilState( +void anv_DestroyDynamicDepthStencilState( VkDevice _device, VkDynamicDepthStencilState _ds_state) { @@ -1978,8 +1953,6 @@ VkResult anv_DestroyDynamicDepthStencilState( ANV_FROM_HANDLE(anv_dynamic_ds_state, ds_state, _ds_state); anv_device_free(device, ds_state); - - return VK_SUCCESS; } VkResult anv_CreateFramebuffer( @@ -2037,7 +2010,7 @@ VkResult anv_CreateFramebuffer( return VK_SUCCESS; } -VkResult anv_DestroyFramebuffer( +void anv_DestroyFramebuffer( VkDevice _device, VkFramebuffer _fb) { @@ -2047,8 +2020,6 @@ VkResult anv_DestroyFramebuffer( anv_DestroyDynamicViewportState(anv_device_to_handle(device), fb->vp_state); anv_device_free(device, fb); - - return VK_SUCCESS; } VkResult anv_CreateRenderPass( @@ -2151,7 +2122,7 @@ VkResult anv_CreateRenderPass( return VK_SUCCESS; } -VkResult anv_DestroyRenderPass( +void anv_DestroyRenderPass( VkDevice _device, VkRenderPass _pass) { @@ -2170,8 +2141,6 @@ VkResult anv_DestroyRenderPass( } anv_device_free(device, pass); - - return VK_SUCCESS; } VkResult anv_GetRenderAreaGranularity( diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index f926cc2b1c0..f0d099e0f25 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -353,14 +353,12 @@ anv_CreateImage(VkDevice device, pImage); } -VkResult +void anv_DestroyImage(VkDevice _device, VkImage _image) { ANV_FROM_HANDLE(anv_device, device, _device); anv_device_free(device, anv_image_from_handle(_image)); - - return VK_SUCCESS; } VkResult anv_GetImageSubresourceLayout( @@ -499,7 +497,7 @@ anv_image_view_fini(struct anv_device *device, anv_state_pool_free(&device->surface_state_pool, iview->surface_state); } -VkResult +void anv_DestroyImageView(VkDevice _device, VkImageView _iview) { ANV_FROM_HANDLE(anv_device, device, _device); @@ -507,8 +505,6 @@ anv_DestroyImageView(VkDevice _device, VkImageView _iview) anv_image_view_fini(device, iview); anv_device_free(device, iview); - - return VK_SUCCESS; } static void @@ -624,7 +620,7 @@ anv_CreateAttachmentView(VkDevice _device, return VK_SUCCESS; } -VkResult +void anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) { ANV_FROM_HANDLE(anv_device, device, _device); @@ -635,6 +631,4 @@ anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) } anv_device_free(device, aview); - - return VK_SUCCESS; } diff --git a/src/vulkan/anv_pipeline.c b/src/vulkan/anv_pipeline.c index daf520f9714..4af4b663c87 100644 --- a/src/vulkan/anv_pipeline.c +++ b/src/vulkan/anv_pipeline.c @@ -56,7 +56,7 @@ VkResult anv_CreateShaderModule( return VK_SUCCESS; } -VkResult anv_DestroyShaderModule( +void anv_DestroyShaderModule( VkDevice _device, VkShaderModule _module) { @@ -64,8 +64,6 @@ VkResult anv_DestroyShaderModule( ANV_FROM_HANDLE(anv_shader_module, module, _module); anv_device_free(device, module); - - return VK_SUCCESS; } VkResult anv_CreateShader( @@ -100,7 +98,7 @@ VkResult anv_CreateShader( return VK_SUCCESS; } -VkResult anv_DestroyShader( +void anv_DestroyShader( VkDevice _device, VkShader _shader) { @@ -108,8 +106,6 @@ VkResult anv_DestroyShader( ANV_FROM_HANDLE(anv_shader, shader, _shader); anv_device_free(device, shader); - - return VK_SUCCESS; } @@ -123,12 +119,10 @@ VkResult anv_CreatePipelineCache( stub_return(VK_SUCCESS); } -VkResult anv_DestroyPipelineCache( +void anv_DestroyPipelineCache( VkDevice _device, VkPipelineCache _cache) { - /* VkPipelineCache is a dummy object. */ - return VK_SUCCESS; } size_t anv_GetPipelineCacheSize( @@ -155,7 +149,7 @@ VkResult anv_MergePipelineCaches( stub_return(VK_UNSUPPORTED); } -VkResult anv_DestroyPipeline( +void anv_DestroyPipeline( VkDevice _device, VkPipeline _pipeline) { @@ -167,8 +161,6 @@ VkResult anv_DestroyPipeline( anv_state_stream_finish(&pipeline->program_stream); anv_state_pool_free(&device->dynamic_state_pool, pipeline->blend_state); anv_device_free(pipeline->device, pipeline); - - return VK_SUCCESS; } static const uint32_t vk_to_gen_primitive_type[] = { @@ -418,7 +410,7 @@ VkResult anv_CreatePipelineLayout( return VK_SUCCESS; } -VkResult anv_DestroyPipelineLayout( +void anv_DestroyPipelineLayout( VkDevice _device, VkPipelineLayout _pipelineLayout) { @@ -426,6 +418,4 @@ VkResult anv_DestroyPipelineLayout( ANV_FROM_HANDLE(anv_pipeline_layout, pipeline_layout, _pipelineLayout); anv_device_free(device, pipeline_layout); - - return VK_SUCCESS; } diff --git a/src/vulkan/anv_query.c b/src/vulkan/anv_query.c index 4ef9d8c4b0c..9464531b8c5 100644 --- a/src/vulkan/anv_query.c +++ b/src/vulkan/anv_query.c @@ -72,7 +72,7 @@ VkResult anv_CreateQueryPool( return result; } -VkResult anv_DestroyQueryPool( +void anv_DestroyQueryPool( VkDevice _device, VkQueryPool _pool) { @@ -82,8 +82,6 @@ VkResult anv_DestroyQueryPool( anv_gem_munmap(pool->bo.map, pool->bo.size); anv_gem_close(device, pool->bo.gem_handle); anv_device_free(device, pool); - - return VK_SUCCESS; } VkResult anv_GetQueryPoolResults( From 65964cd49b0fd7cbc90805c8c18b4fd39f975a9c Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 21:10:20 -0700 Subject: [PATCH 28/76] vk/0.170.2: Re-arrange parameters of vkCmdDraw[Indexed] --- include/vulkan/vulkan.h | 16 ++++++++-------- src/vulkan/anv_meta.c | 4 ++-- src/vulkan/gen7_cmd_buffer.c | 12 ++++++------ src/vulkan/gen8_cmd_buffer.c | 12 ++++++------ 4 files changed, 22 insertions(+), 22 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 9962cc17179..9cee1c545b6 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2186,8 +2186,8 @@ typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffe typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); @@ -2811,18 +2811,18 @@ void VKAPI vkCmdBindVertexBuffers( void VKAPI vkCmdDraw( VkCmdBuffer cmdBuffer, - uint32_t firstVertex, uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount); + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); void VKAPI vkCmdDrawIndexed( VkCmdBuffer cmdBuffer, - uint32_t firstIndex, uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount); + uint32_t firstInstance); void VKAPI vkCmdDrawIndirect( VkCmdBuffer cmdBuffer, diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 949e5a16601..77c47dac247 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -414,7 +414,7 @@ meta_emit_clear(struct anv_cmd_buffer *cmd_buffer, device->meta_state.shared.cb_state); ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer), - 0, 3, 0, num_instances); + 3, num_instances, 0, 0); } void @@ -926,7 +926,7 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, device->meta_state.blit.pipeline_layout, 0, 1, &set, 0, NULL); - ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer), 0, 3, 0, 1); + ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer), 3, 1, 0, 0); ANV_CALL(CmdEndRenderPass)(anv_cmd_buffer_to_handle(cmd_buffer)); diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index 5803569502f..2b9ed5772e1 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -332,10 +332,10 @@ gen7_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer) void gen7_CmdDraw( VkCmdBuffer cmdBuffer, - uint32_t firstVertex, uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount) + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; @@ -354,11 +354,11 @@ void gen7_CmdDraw( void gen7_CmdDrawIndexed( VkCmdBuffer cmdBuffer, - uint32_t firstIndex, uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount) + uint32_t firstInstance) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index 3ed32e8de3d..f48519e51b9 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -184,10 +184,10 @@ gen8_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer) void gen8_CmdDraw( VkCmdBuffer cmdBuffer, - uint32_t firstVertex, uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount) + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); @@ -204,11 +204,11 @@ void gen8_CmdDraw( void gen8_CmdDrawIndexed( VkCmdBuffer cmdBuffer, - uint32_t firstIndex, uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount) + uint32_t firstInstance) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); From a6eba403e2a2274c8aca62a59a206fc583134b4d Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Mon, 5 Oct 2015 21:17:12 -0700 Subject: [PATCH 29/76] vk/0.170.2: Update to the new queue family properties query --- include/vulkan/vulkan.h | 15 +++++---------- src/vulkan/anv_device.c | 21 ++++++++------------- 2 files changed, 13 insertions(+), 23 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 9cee1c545b6..69decf94ce6 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1294,7 +1294,7 @@ typedef struct { VkQueueFlags queueFlags; uint32_t queueCount; VkBool32 supportsTimestamps; -} VkPhysicalDeviceQueueProperties; +} VkQueueFamilyProperties; typedef struct { VkMemoryPropertyFlags propertyFlags; @@ -2074,8 +2074,7 @@ typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevi typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); @@ -2257,14 +2256,10 @@ VkResult VKAPI vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -VkResult VKAPI vkGetPhysicalDeviceQueueCount( +VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, - uint32_t* pCount); - -VkResult VKAPI vkGetPhysicalDeviceQueueProperties( - VkPhysicalDevice physicalDevice, - uint32_t count, - VkPhysicalDeviceQueueProperties* pQueueProperties); + uint32_t* pCount, + VkQueueFamilyProperties* pQueueFamilyProperties); VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index dd8e3ffa0af..31b7565b984 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -451,23 +451,18 @@ VkResult anv_GetPhysicalDeviceProperties( return VK_SUCCESS; } -VkResult anv_GetPhysicalDeviceQueueCount( +VkResult anv_GetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, - uint32_t* pCount) + uint32_t* pCount, + VkQueueFamilyProperties* pQueueFamilyProperties) { - *pCount = 1; + if (pQueueFamilyProperties == NULL) { + *pCount = 1; + } - return VK_SUCCESS; -} + assert(*pCount >= 1); -VkResult anv_GetPhysicalDeviceQueueProperties( - VkPhysicalDevice physicalDevice, - uint32_t count, - VkPhysicalDeviceQueueProperties* pQueueProperties) -{ - assert(count == 1); - - *pQueueProperties = (VkPhysicalDeviceQueueProperties) { + *pQueueFamilyProperties = (VkQueueFamilyProperties) { .queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT, From 8ba684cbad6963be54f27aeeb42708069f8d9bd3 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 09:25:03 -0700 Subject: [PATCH 30/76] vk/0.170.2: Rename extension and layer query functions --- include/vulkan/vulkan.h | 16 ++++++++-------- src/vulkan/anv_device.c | 8 ++++---- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 69decf94ce6..26fc48b5acb 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2080,10 +2080,10 @@ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instanc typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); @@ -2281,22 +2281,22 @@ VkResult VKAPI vkCreateDevice( void VKAPI vkDestroyDevice( VkDevice device); -VkResult VKAPI vkGetGlobalExtensionProperties( +VkResult VKAPI vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( +VkResult VKAPI vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -VkResult VKAPI vkGetGlobalLayerProperties( +VkResult VKAPI vkEnumerateInstanceLayerProperties( uint32_t* pCount, VkLayerProperties* pProperties); -VkResult VKAPI vkGetPhysicalDeviceLayerProperties( +VkResult VKAPI vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 31b7565b984..f92b5fbf21b 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -674,7 +674,7 @@ void anv_DestroyDevice( anv_instance_free(device->instance, device); } -VkResult anv_GetGlobalExtensionProperties( +VkResult anv_EnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) @@ -692,7 +692,7 @@ VkResult anv_GetGlobalExtensionProperties( return VK_SUCCESS; } -VkResult anv_GetPhysicalDeviceExtensionProperties( +VkResult anv_EnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, @@ -711,7 +711,7 @@ VkResult anv_GetPhysicalDeviceExtensionProperties( return VK_SUCCESS; } -VkResult anv_GetGlobalLayerProperties( +VkResult anv_EnumerateInstanceLayerProperties( uint32_t* pCount, VkLayerProperties* pProperties) { @@ -724,7 +724,7 @@ VkResult anv_GetGlobalLayerProperties( return vk_error(VK_ERROR_INVALID_LAYER); } -VkResult anv_GetPhysicalDeviceLayerProperties( +VkResult anv_EnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) From a145acd8121bb563fa01e059b890974dae757c5b Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 09:32:01 -0700 Subject: [PATCH 31/76] vk/0.170.2: Remove the pCount parameter from AllocDescriptorSets --- include/vulkan/vulkan.h | 5 ++--- src/vulkan/anv_device.c | 19 +++++++++---------- src/vulkan/anv_meta.c | 3 +-- 3 files changed, 12 insertions(+), 15 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 26fc48b5acb..470e2f4de2c 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2153,7 +2153,7 @@ typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescri typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); +typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); @@ -2651,8 +2651,7 @@ VkResult VKAPI vkAllocDescriptorSets( VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets, - uint32_t* pCount); + VkDescriptorSet* pDescriptorSets); VkResult VKAPI vkFreeDescriptorSets( VkDevice device, diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index f92b5fbf21b..3ab91726024 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1652,29 +1652,28 @@ VkResult anv_AllocDescriptorSets( VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets, - uint32_t* pCount) + VkDescriptorSet* pDescriptorSets) { ANV_FROM_HANDLE(anv_device, device, _device); - VkResult result; + VkResult result = VK_SUCCESS; struct anv_descriptor_set *set; + uint32_t i; - for (uint32_t i = 0; i < count; i++) { + for (i = 0; i < count; i++) { ANV_FROM_HANDLE(anv_descriptor_set_layout, layout, pSetLayouts[i]); result = anv_descriptor_set_create(device, layout, &set); - if (result != VK_SUCCESS) { - *pCount = i; - return result; - } + if (result != VK_SUCCESS) + break; pDescriptorSets[i] = anv_descriptor_set_to_handle(set); } - *pCount = count; + if (result != VK_SUCCESS) + anv_FreeDescriptorSets(_device, descriptorPool, i, pDescriptorSets); - return VK_SUCCESS; + return result; } VkResult anv_FreeDescriptorSets( diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 77c47dac247..0fb4c50adba 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -806,11 +806,10 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, sizeof(struct vue_header), }); - uint32_t count; VkDescriptorSet set; anv_AllocDescriptorSets(anv_device_to_handle(device), dummy_desc_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, - 1, &device->meta_state.blit.ds_layout, &set, &count); + 1, &device->meta_state.blit.ds_layout, &set); anv_UpdateDescriptorSets(anv_device_to_handle(device), 1, /* writeCount */ (VkWriteDescriptorSet[]) { From 02a9be31d617ff83f02ff4ce7d3c4288b72ce31b Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 09:37:21 -0700 Subject: [PATCH 32/76] vk/0.170.2: Add the flags parameter to GetPhysicalDeviceImageFormatProperties --- include/vulkan/vulkan.h | 3 ++- src/vulkan/anv_formats.c | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 470e2f4de2c..408e4045ad5 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2071,7 +2071,7 @@ typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties); @@ -2246,6 +2246,7 @@ VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, + VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); VkResult VKAPI vkGetPhysicalDeviceLimits( diff --git a/src/vulkan/anv_formats.c b/src/vulkan/anv_formats.c index 6173ee7872a..cae575bb04b 100644 --- a/src/vulkan/anv_formats.c +++ b/src/vulkan/anv_formats.c @@ -327,6 +327,7 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, + VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); From d1908d2c332a4f2d18940bbe14f1e584b1a11ffc Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 09:40:39 -0700 Subject: [PATCH 33/76] vk/0.170.2: Rework parameters to CmdClearDepthStencil functions --- include/vulkan/vulkan.h | 12 +++++------- src/vulkan/anv_meta.c | 8 +++----- 2 files changed, 8 insertions(+), 12 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 408e4045ad5..b7a5d6f9f01 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2199,9 +2199,9 @@ typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects); typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); @@ -2912,8 +2912,7 @@ void VKAPI vkCmdClearDepthStencilImage( VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, - float depth, - uint32_t stencil, + const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); @@ -2927,10 +2926,9 @@ void VKAPI vkCmdClearColorAttachment( void VKAPI vkCmdClearDepthStencilAttachment( VkCmdBuffer cmdBuffer, - VkImageAspectFlags imageAspectMask, + VkImageAspectFlags aspectMask, VkImageLayout imageLayout, - float depth, - uint32_t stencil, + const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects); diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 0fb4c50adba..4e6ddf49f76 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -1654,8 +1654,7 @@ void anv_CmdClearDepthStencilImage( VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, - float depth, - uint32_t stencil, + const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { @@ -1675,10 +1674,9 @@ void anv_CmdClearColorAttachment( void anv_CmdClearDepthStencilAttachment( VkCmdBuffer cmdBuffer, - VkImageAspectFlags imageAspectMask, + VkImageAspectFlags aspectMask, VkImageLayout imageLayout, - float depth, - uint32_t stencil, + const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects) { From ba2254aa79af76cabad921538b70c0bd1943c4c0 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 09:50:01 -0700 Subject: [PATCH 34/76] vulkan.h: Move stuff around This has no functional change but substantially decreases the diff with the 0.170.2 header. --- include/vulkan/vulkan.h | 161 ++++++++++++++++++++-------------------- 1 file changed, 81 insertions(+), 80 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index b7a5d6f9f01..c7b7f47c3c3 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -76,20 +76,6 @@ extern "C" { -#define VK_LOD_CLAMP_NONE MAX_FLOAT -#define VK_LAST_MIP_LEVEL UINT32_MAX -#define VK_LAST_ARRAY_SLICE UINT32_MAX -#define VK_WHOLE_SIZE UINT64_MAX -#define VK_ATTACHMENT_UNUSED UINT32_MAX -#define VK_TRUE 1 -#define VK_FALSE 0 -#define VK_NULL_HANDLE 0 -#define VK_MAX_PHYSICAL_DEVICE_NAME 256 -#define VK_UUID_LENGTH 16 -#define VK_MAX_MEMORY_TYPES 32 -#define VK_MAX_MEMORY_HEAPS 16 -#define VK_MAX_EXTENSION_NAME 256 -#define VK_MAX_DESCRIPTION 256 VK_DEFINE_HANDLE(VkInstance) VK_DEFINE_HANDLE(VkPhysicalDevice) @@ -123,6 +109,21 @@ VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) VK_DEFINE_NONDISP_HANDLE(VkCmdPool) +#define VK_LOD_CLAMP_NONE MAX_FLOAT +#define VK_LAST_MIP_LEVEL UINT32_MAX +#define VK_LAST_ARRAY_SLICE UINT32_MAX +#define VK_WHOLE_SIZE UINT64_MAX +#define VK_ATTACHMENT_UNUSED UINT32_MAX +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_NULL_HANDLE 0 +#define VK_MAX_PHYSICAL_DEVICE_NAME 256 +#define VK_UUID_LENGTH 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME 256 +#define VK_MAX_DESCRIPTION 256 + typedef enum { VK_SUCCESS = 0, @@ -480,6 +481,21 @@ typedef enum { VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF } VkSharingMode; +typedef enum { + 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_SOURCE_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, + VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + typedef enum { VK_IMAGE_VIEW_TYPE_1D = 0, VK_IMAGE_VIEW_TYPE_2D = 1, @@ -748,21 +764,6 @@ typedef enum { VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF } VkDescriptorSetUsage; -typedef enum { - 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_SOURCE_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, - VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, - VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - typedef enum { VK_ATTACHMENT_LOAD_OP_LOAD = 0, VK_ATTACHMENT_LOAD_OP_CLEAR = 1, @@ -855,6 +856,16 @@ typedef enum { } VkImageUsageFlagBits; typedef VkFlags VkImageUsageFlags; +typedef enum { + VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + typedef enum { VK_QUEUE_GRAPHICS_BIT = 0x00000001, VK_QUEUE_COMPUTE_BIT = 0x00000002, @@ -944,14 +955,12 @@ typedef enum { typedef VkFlags VkBufferCreateFlags; typedef enum { - VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; typedef enum { VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, @@ -1062,14 +1071,6 @@ typedef enum { } VkCmdBufferResetFlagBits; typedef VkFlags VkCmdBufferResetFlags; -typedef enum { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - typedef enum { VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, } VkQueryControlFlagBits; @@ -1180,6 +1181,12 @@ typedef struct { VkFormatFeatureFlags optimalTilingFeatures; } VkFormatProperties; +typedef struct { + int32_t width; + int32_t height; + int32_t depth; +} VkExtent3D; + typedef struct { uint64_t maxResourceSize; uint32_t maxSamples; @@ -1365,12 +1372,6 @@ typedef struct { uint32_t memoryTypeBits; } VkMemoryRequirements; -typedef struct { - int32_t width; - int32_t height; - int32_t depth; -} VkExtent3D; - typedef struct { VkImageAspect aspect; VkExtent3D imageGranularity; @@ -1600,6 +1601,30 @@ typedef struct { uint32_t patchControlPoints; } VkPipelineTessellationStateCreateInfo; +typedef struct { + float originX; + float originY; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct { + int32_t width; + int32_t height; +} VkExtent2D; + +typedef struct { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + typedef struct { VkStructureType sType; const void* pNext; @@ -1787,30 +1812,6 @@ typedef struct { uint32_t count; } VkCopyDescriptorSet; -typedef struct { - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct { - int32_t width; - int32_t height; -} VkExtent2D; - -typedef struct { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - typedef struct { VkStructureType sType; const void* pNext; @@ -1979,6 +1980,11 @@ typedef union { uint32_t u32[4]; } VkClearColorValue; +typedef struct { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + typedef struct { VkOffset3D offset; VkExtent3D extent; @@ -1992,11 +1998,6 @@ typedef struct { VkExtent3D extent; } VkImageResolve; -typedef struct { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - typedef union { VkClearColorValue color; VkClearDepthStencilValue depthStencil; From 81c7fa877274b5767657497699f1d46981784fc9 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:04:04 -0700 Subject: [PATCH 35/76] vk/0.170.2: Rework blits to use ImageSubresourceCopy --- include/vulkan/vulkan.h | 17 ++++++++++++----- src/vulkan/anv_meta.c | 19 ++++++++++++++----- 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index c7b7f47c3c3..cec176f3bf9 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1949,18 +1949,25 @@ typedef struct { } VkBufferCopy; typedef struct { - VkImageSubresource srcSubresource; + VkImageAspect aspect; + uint32_t mipLevel; + uint32_t arrayLayer; + uint32_t arraySize; +} VkImageSubresourceCopy; + +typedef struct { + VkImageSubresourceCopy srcSubresource; VkOffset3D srcOffset; - VkImageSubresource destSubresource; + VkImageSubresourceCopy destSubresource; VkOffset3D destOffset; VkExtent3D extent; } VkImageCopy; typedef struct { - VkImageSubresource srcSubresource; + VkImageSubresourceCopy srcSubresource; VkOffset3D srcOffset; VkExtent3D srcExtent; - VkImageSubresource destSubresource; + VkImageSubresourceCopy destSubresource; VkOffset3D destOffset; VkExtent3D destExtent; } VkImageBlit; @@ -1969,7 +1976,7 @@ typedef struct { VkDeviceSize bufferOffset; uint32_t bufferRowLength; uint32_t bufferImageHeight; - VkImageSubresource imageSubresource; + VkImageSubresourceCopy imageSubresource; VkOffset3D imageOffset; VkExtent3D imageExtent; } VkBufferImageCopy; diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 4e6ddf49f76..ad65403b100 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -502,13 +502,13 @@ meta_blit_get_src_image_view_type(const struct anv_image *src_image) static uint32_t meta_blit_get_dest_view_base_array_slice(const struct anv_image *dest_image, - const VkImageSubresource *dest_subresource, + const VkImageSubresourceCopy *dest_subresource, const VkOffset3D *dest_offset) { switch (dest_image->type) { case VK_IMAGE_TYPE_1D: case VK_IMAGE_TYPE_2D: - return dest_subresource->arraySlice; + return dest_subresource->arrayLayer; case VK_IMAGE_TYPE_3D: /* HACK: Vulkan does not allow attaching a 3D image to a framebuffer, * but meta does it anyway. When doing so, we translate the @@ -1163,7 +1163,7 @@ void anv_CmdCopyImage( .aspectMask = 1 << pRegions[r].srcSubresource.aspect, .baseMipLevel = pRegions[r].srcSubresource.mipLevel, .mipLevels = 1, - .baseArraySlice = pRegions[r].srcSubresource.arraySlice, + .baseArraySlice = pRegions[r].srcSubresource.arrayLayer, .arraySize = 1 }, }, @@ -1180,6 +1180,9 @@ void anv_CmdCopyImage( &pRegions[r].destSubresource, &pRegions[r].destOffset); + if (pRegions[r].srcSubresource.arraySize > 1) + anv_finishme("FINISHME: copy multiple array layers"); + if (pRegions[r].extent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); @@ -1249,7 +1252,7 @@ void anv_CmdBlitImage( .aspectMask = 1 << pRegions[r].srcSubresource.aspect, .baseMipLevel = pRegions[r].srcSubresource.mipLevel, .mipLevels = 1, - .baseArraySlice = pRegions[r].srcSubresource.arraySlice, + .baseArraySlice = pRegions[r].srcSubresource.arrayLayer, .arraySize = 1 }, }, @@ -1266,6 +1269,9 @@ void anv_CmdBlitImage( &pRegions[r].destSubresource, &pRegions[r].destOffset); + if (pRegions[r].srcSubresource.arraySize > 1) + anv_finishme("FINISHME: copy multiple array layers"); + if (pRegions[r].destExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); @@ -1446,6 +1452,9 @@ void anv_CmdCopyImageToBuffer( meta_prepare_blit(cmd_buffer, &saved_state); for (unsigned r = 0; r < regionCount; r++) { + if (pRegions[r].imageSubresource.arraySize > 1) + anv_finishme("FINISHME: copy multiple array layers"); + if (pRegions[r].imageExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); @@ -1466,7 +1475,7 @@ void anv_CmdCopyImageToBuffer( .aspectMask = 1 << pRegions[r].imageSubresource.aspect, .baseMipLevel = pRegions[r].imageSubresource.mipLevel, .mipLevels = 1, - .baseArraySlice = pRegions[r].imageSubresource.arraySlice, + .baseArraySlice = pRegions[r].imageSubresource.arrayLayer, .arraySize = 1 }, }, From bd4cde708a2ad0bea04eb318d7c54447ccbbc7af Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:07:47 -0700 Subject: [PATCH 36/76] vk/0.170.2: Rename fields in VkClearColorValue --- include/vulkan/vulkan.h | 6 +++--- src/vulkan/anv_device.c | 12 ++++++------ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index cec176f3bf9..2c448b54f38 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1982,9 +1982,9 @@ typedef struct { } VkBufferImageCopy; typedef union { - float f32[4]; - int32_t s32[4]; - uint32_t u32[4]; + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; } VkClearColorValue; typedef struct { diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 3ab91726024..a956c3cdf44 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -547,12 +547,12 @@ static void anv_device_init_border_colors(struct anv_device *device) { static const VkClearColorValue border_colors[] = { - [VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK] = { .f32 = { 0.0, 0.0, 0.0, 0.0 } }, - [VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK] = { .f32 = { 0.0, 0.0, 0.0, 1.0 } }, - [VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE] = { .f32 = { 1.0, 1.0, 1.0, 1.0 } }, - [VK_BORDER_COLOR_INT_TRANSPARENT_BLACK] = { .u32 = { 0, 0, 0, 0 } }, - [VK_BORDER_COLOR_INT_OPAQUE_BLACK] = { .u32 = { 0, 0, 0, 1 } }, - [VK_BORDER_COLOR_INT_OPAQUE_WHITE] = { .u32 = { 1, 1, 1, 1 } }, + [VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK] = { .float32 = { 0.0, 0.0, 0.0, 0.0 } }, + [VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK] = { .float32 = { 0.0, 0.0, 0.0, 1.0 } }, + [VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE] = { .float32 = { 1.0, 1.0, 1.0, 1.0 } }, + [VK_BORDER_COLOR_INT_TRANSPARENT_BLACK] = { .uint32 = { 0, 0, 0, 0 } }, + [VK_BORDER_COLOR_INT_OPAQUE_BLACK] = { .uint32 = { 0, 0, 0, 1 } }, + [VK_BORDER_COLOR_INT_OPAQUE_WHITE] = { .uint32 = { 1, 1, 1, 1 } }, }; device->border_colors = From 588d40e97a9f4870fab59ab2e04d661945c3c2e1 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:09:47 -0700 Subject: [PATCH 37/76] vk/0.170.2: Use ImageSubresourceCopy in ImageResolve --- include/vulkan/vulkan.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 2c448b54f38..bdd44a01073 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1998,9 +1998,9 @@ typedef struct { } VkRect3D; typedef struct { - VkImageSubresource srcSubresource; + VkImageSubresourceCopy srcSubresource; VkOffset3D srcOffset; - VkImageSubresource destSubresource; + VkImageSubresourceCopy destSubresource; VkOffset3D destOffset; VkExtent3D extent; } VkImageResolve; From cc389b1482f2860b83d277cebca0c2058c403410 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:11:50 -0700 Subject: [PATCH 38/76] vk/0.170.2: Rename cs to stage in ComputePipelineCreateInfo --- include/vulkan/vulkan.h | 2 +- src/vulkan/gen8_pipeline.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index bdd44a01073..62fbe97c616 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1714,7 +1714,7 @@ typedef struct { typedef struct { VkStructureType sType; const void* pNext; - VkPipelineShaderStageCreateInfo cs; + VkPipelineShaderStageCreateInfo stage; VkPipelineCreateFlags flags; VkPipelineLayout layout; VkPipeline basePipelineHandle; diff --git a/src/vulkan/gen8_pipeline.c b/src/vulkan/gen8_pipeline.c index 4900715a47a..0e2526fce20 100644 --- a/src/vulkan/gen8_pipeline.c +++ b/src/vulkan/gen8_pipeline.c @@ -571,7 +571,7 @@ VkResult gen8_compute_pipeline_create( memset(pipeline->shaders, 0, sizeof(pipeline->shaders)); pipeline->shaders[VK_SHADER_STAGE_COMPUTE] = - anv_shader_from_handle(pCreateInfo->cs.shader); + anv_shader_from_handle(pCreateInfo->stage.shader); pipeline->use_repclear = false; From 19018c9f13f43c43af4bd95267ab469802c27854 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:20:10 -0700 Subject: [PATCH 39/76] vk/0.170.2: Add a stage field to ShaderCreateInfo --- include/vulkan/vulkan.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 62fbe97c616..3498b46ab62 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1535,6 +1535,7 @@ typedef struct { VkShaderModule module; const char* pName; VkShaderCreateFlags flags; + VkShaderStage stage; } VkShaderCreateInfo; typedef struct { From 6b5ce5daf5145a1e63ca28c537689583056ac28d Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Mon, 5 Oct 2015 18:13:48 -0700 Subject: [PATCH 40/76] vk: Update comments for anv_image_view - Document the extent member. It's the extent of the view's base level. - s/VkAttachmentView/VkImageView/ --- src/vulkan/anv_private.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index a0d4f8c2867..b0657cfbd14 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1244,12 +1244,12 @@ struct anv_buffer_view { }; struct anv_image_view { - const struct anv_image *image; /**< VkAttachmentViewCreateInfo::image */ - const struct anv_format *format; /**< VkAttachmentViewCreateInfo::format */ + const struct anv_image *image; /**< VkImageViewCreateInfo::image */ + const struct anv_format *format; /**< VkImageViewCreateInfo::format */ struct anv_state surface_state; /**< RENDER_SURFACE_STATE */ struct anv_bo *bo; uint32_t offset; /**< Offset into bo. */ - VkExtent3D extent; + VkExtent3D extent; /**< Extent of VkImageViewCreateInfo::baseMipLevel. */ }; enum anv_attachment_view_type { From d4446a7e58e4c57da68432ed108320936a910e5d Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 11:42:43 -0700 Subject: [PATCH 41/76] vk: Merge anv_attachment_view into anv_image_view This prepares for merging VkAttachmentView into VkImageView. --- src/vulkan/anv_cmd_buffer.c | 13 ++++---- src/vulkan/anv_device.c | 9 +++--- src/vulkan/anv_image.c | 49 ++++++++++++++---------------- src/vulkan/anv_meta.c | 58 +++++++++++++++++++----------------- src/vulkan/anv_private.h | 21 ++++--------- src/vulkan/gen7_cmd_buffer.c | 3 +- src/vulkan/gen7_state.c | 5 +--- src/vulkan/gen8_cmd_buffer.c | 3 +- src/vulkan/gen8_state.c | 5 +--- 9 files changed, 71 insertions(+), 95 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 64f10ffe74e..470ea11df6f 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -431,11 +431,8 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, * put the color attachments into the binding table. */ for (uint32_t a = 0; a < attachments; a++) { - const struct anv_attachment_view *aview = + const struct anv_image_view *iview = fb->attachments[subpass->color_attachments[a]]; - const struct anv_image_view *iview = &aview->image_view; - - assert(aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR); bt_map[a] = iview->surface_state.offset + state_offset; add_surface_state_reloc(cmd_buffer, iview->surface_state, @@ -814,7 +811,7 @@ VkResult anv_ResetCommandPool( /** * Return NULL if the current subpass has no depthstencil attachment. */ -const struct anv_attachment_view * +const struct anv_image_view * anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer) { const struct anv_subpass *subpass = cmd_buffer->state.subpass; @@ -823,10 +820,10 @@ anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer) if (subpass->depth_stencil_attachment == VK_ATTACHMENT_UNUSED) return NULL; - const struct anv_attachment_view *aview = + const struct anv_image_view *iview = fb->attachments[subpass->depth_stencil_attachment]; - assert(aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL); + assert(anv_format_is_depth_or_stencil(iview->format)); - return aview; + return iview; } diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index a956c3cdf44..a7430b858b5 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1960,7 +1960,7 @@ VkResult anv_CreateFramebuffer( assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO); size_t size = sizeof(*framebuffer) + - sizeof(struct anv_attachment_view *) * pCreateInfo->attachmentCount; + sizeof(struct anv_image_view *) * pCreateInfo->attachmentCount; framebuffer = anv_device_alloc(device, size, 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); if (framebuffer == NULL) @@ -1968,10 +1968,9 @@ VkResult anv_CreateFramebuffer( framebuffer->attachment_count = pCreateInfo->attachmentCount; for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { - ANV_FROM_HANDLE(anv_attachment_view, aview, - pCreateInfo->pAttachments[i].view); - - framebuffer->attachments[i] = aview; + VkAttachmentView _aview = pCreateInfo->pAttachments[i].view; + VkImageView _iview = { _aview.handle }; + framebuffer->attachments[i] = anv_image_view_from_handle(_iview); } framebuffer->width = pCreateInfo->width; diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index f0d099e0f25..8eb5a603c2b 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -490,41 +490,32 @@ anv_CreateImageView(VkDevice _device, return VK_SUCCESS; } -static void -anv_image_view_fini(struct anv_device *device, - struct anv_image_view *iview) -{ - anv_state_pool_free(&device->surface_state_pool, iview->surface_state); -} - void anv_DestroyImageView(VkDevice _device, VkImageView _iview) { ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_image_view, iview, _iview); - anv_image_view_fini(device, iview); + anv_state_pool_free(&device->surface_state_pool, iview->surface_state); anv_device_free(device, iview); } static void -anv_depth_stencil_view_init(struct anv_attachment_view *aview, +anv_depth_stencil_view_init(struct anv_image_view *iview, const VkAttachmentViewCreateInfo *pCreateInfo) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - aview->attachment_type = ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL; - /* XXX: We don't handle any of these */ anv_assert(pCreateInfo->mipLevel == 0); anv_assert(pCreateInfo->baseArraySlice == 0); anv_assert(pCreateInfo->arraySize == 1); - aview->image_view.image = image; - aview->image_view.format = anv_format_for_vk_format(pCreateInfo->format); + iview->image = image; + iview->format = anv_format_for_vk_format(pCreateInfo->format); assert(anv_format_is_depth_or_stencil(image->format)); - assert(anv_format_is_depth_or_stencil(aview->image_view.format)); + assert(anv_format_is_depth_or_stencil(iview->format)); } struct anv_surface * @@ -574,17 +565,17 @@ anv_image_get_surface_for_color_attachment(struct anv_image *image) } void -anv_color_attachment_view_init(struct anv_attachment_view *aview, +anv_color_attachment_view_init(struct anv_image_view *iview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { switch (device->info.gen) { case 7: - gen7_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer); + gen7_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer); break; case 8: - gen8_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer); + gen8_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer); break; default: unreachable("unsupported gen\n"); @@ -597,25 +588,25 @@ anv_CreateAttachmentView(VkDevice _device, VkAttachmentView *pView) { ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_attachment_view *aview; + struct anv_image_view *iview; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO); - aview = anv_device_alloc(device, sizeof(*aview), 8, + iview = anv_device_alloc(device, sizeof(*iview), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (aview == NULL) + if (iview == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); if (anv_format_is_depth_or_stencil(format)) { - anv_depth_stencil_view_init(aview, pCreateInfo); + anv_depth_stencil_view_init(iview, pCreateInfo); } else { - anv_color_attachment_view_init(aview, device, pCreateInfo, NULL); + anv_color_attachment_view_init(iview, device, pCreateInfo, NULL); } - *pView = anv_attachment_view_to_handle(aview); + pView->handle = anv_image_view_to_handle(iview).handle; return VK_SUCCESS; } @@ -624,11 +615,15 @@ void anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) { ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_attachment_view, aview, _aview); + VkImageView _iview = { .handle = _aview.handle }; + ANV_FROM_HANDLE(anv_image_view, iview, _iview); - if (aview->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR) { - anv_image_view_fini(device, &aview->image_view); + /* Depth and stencil render targets have no RENDER_SURFACE_STATE. Instead, + * they use 3DSTATE_DEPTH_BUFFER and 3DSTATE_STENCIL_BUFFER. + */ + if (!anv_format_is_depth_or_stencil(iview->format)) { + anv_state_pool_free(&device->surface_state_pool, iview->surface_state); } - anv_device_free(device, aview); + anv_device_free(device, iview); } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index ad65403b100..c214dc30a4c 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -733,12 +733,15 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, VkOffset3D src_offset, VkExtent3D src_extent, struct anv_image *dest_image, - struct anv_attachment_view *dest_aview, + struct anv_image_view *dest_iview, VkOffset3D dest_offset, VkExtent3D dest_extent) { struct anv_device *device = cmd_buffer->device; - struct anv_image_view *dest_iview = &dest_aview->image_view; + + VkImageView dest_iview_h = anv_image_view_to_handle(dest_iview); + VkAttachmentView dest_aview_h = { .handle = dest_iview_h.handle }; + VkDescriptorPool dummy_desc_pool = { .handle = 1 }; struct blit_vb_data { @@ -836,7 +839,7 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, .attachmentCount = 1, .pAttachments = (VkAttachmentBindInfo[]) { { - .view = anv_attachment_view_to_handle(dest_aview), + .view = dest_aview_h, .layout = VK_IMAGE_LAYOUT_GENERAL } }, @@ -1021,8 +1024,8 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, }, cmd_buffer); - struct anv_attachment_view dest_aview; - anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, + struct anv_image_view dest_iview; + anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = dest_image, @@ -1039,7 +1042,7 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, (VkOffset3D) { 0, 0, 0 }, (VkExtent3D) { width, height, 1 }, anv_image_from_handle(dest_image), - &dest_aview, + &dest_iview, (VkOffset3D) { 0, 0, 0 }, (VkExtent3D) { width, height, 1 }); @@ -1186,8 +1189,8 @@ void anv_CmdCopyImage( if (pRegions[r].extent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_attachment_view dest_aview; - anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, + struct anv_image_view dest_iview; + anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1202,7 +1205,7 @@ void anv_CmdCopyImage( src_image, &src_iview, pRegions[r].srcOffset, pRegions[r].extent, - dest_image, &dest_aview, + dest_image, &dest_iview, dest_offset, pRegions[r].extent); } @@ -1275,8 +1278,8 @@ void anv_CmdBlitImage( if (pRegions[r].destExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_attachment_view dest_aview; - anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, + struct anv_image_view dest_iview; + anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1291,7 +1294,7 @@ void anv_CmdBlitImage( src_image, &src_iview, pRegions[r].srcOffset, pRegions[r].srcExtent, - dest_image, &dest_aview, + dest_image, &dest_iview, dest_offset, pRegions[r].destExtent); } @@ -1405,8 +1408,8 @@ void anv_CmdCopyBufferToImage( if (pRegions[r].imageExtent.depth > 1) anv_finishme("FINISHME: copy multiple depth layers"); - struct anv_attachment_view dest_aview; - anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, + struct anv_image_view dest_iview; + anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = anv_image_to_handle(dest_image), @@ -1423,7 +1426,7 @@ void anv_CmdCopyBufferToImage( (VkOffset3D) { 0, 0, 0 }, pRegions[r].imageExtent, dest_image, - &dest_aview, + &dest_iview, dest_offset, pRegions[r].imageExtent); @@ -1490,8 +1493,8 @@ void anv_CmdCopyImageToBuffer( dest_format, &pRegions[r]); - struct anv_attachment_view dest_aview; - anv_color_attachment_view_init(&dest_aview, cmd_buffer->device, + struct anv_image_view dest_iview; + anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = destImage, @@ -1508,7 +1511,7 @@ void anv_CmdCopyImageToBuffer( pRegions[r].imageOffset, pRegions[r].imageExtent, anv_image_from_handle(destImage), - &dest_aview, + &dest_iview, (VkOffset3D) { 0, 0, 0 }, pRegions[r].imageExtent); @@ -1555,8 +1558,8 @@ void anv_CmdClearColorImage( for (uint32_t r = 0; r < rangeCount; r++) { for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { for (uint32_t s = 0; s < pRanges[r].arraySize; s++) { - struct anv_attachment_view aview; - anv_color_attachment_view_init(&aview, cmd_buffer->device, + struct anv_image_view iview; + anv_color_attachment_view_init(&iview, cmd_buffer->device, &(VkAttachmentViewCreateInfo) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, .image = _image, @@ -1567,7 +1570,8 @@ void anv_CmdClearColorImage( }, cmd_buffer); - struct anv_image_view *iview = &aview.image_view; + VkImageView iview_h = anv_image_view_to_handle(&iview); + VkAttachmentView aview_h = { .handle = iview_h.handle }; VkFramebuffer fb; anv_CreateFramebuffer(anv_device_to_handle(cmd_buffer->device), @@ -1576,12 +1580,12 @@ void anv_CmdClearColorImage( .attachmentCount = 1, .pAttachments = (VkAttachmentBindInfo[]) { { - .view = anv_attachment_view_to_handle(&aview), + .view = aview_h, .layout = VK_IMAGE_LAYOUT_GENERAL } }, - .width = iview->extent.width, - .height = iview->extent.height, + .width = iview.extent.width, + .height = iview.extent.height, .layers = 1 }, &fb); @@ -1592,7 +1596,7 @@ void anv_CmdClearColorImage( .attachmentCount = 1, .pAttachments = &(VkAttachmentDescription) { .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, - .format = iview->format->vk_format, + .format = iview.format->vk_format, .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD, .storeOp = VK_ATTACHMENT_STORE_OP_STORE, .initialLayout = VK_IMAGE_LAYOUT_GENERAL, @@ -1628,8 +1632,8 @@ void anv_CmdClearColorImage( .renderArea = { .offset = { 0, 0, }, .extent = { - .width = iview->extent.width, - .height = iview->extent.height, + .width = iview.extent.width, + .height = iview.extent.height, }, }, .renderPass = pass, diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index b0657cfbd14..3326625ebb3 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -994,7 +994,7 @@ anv_cmd_buffer_push_constants(struct anv_cmd_buffer *cmd_buffer, void anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer, struct anv_render_pass *pass, const VkClearValue *clear_values); -const struct anv_attachment_view * +const struct anv_image_view * anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer); void anv_cmd_buffer_dump(struct anv_cmd_buffer *cmd_buffer); @@ -1252,16 +1252,6 @@ struct anv_image_view { VkExtent3D extent; /**< Extent of VkImageViewCreateInfo::baseMipLevel. */ }; -enum anv_attachment_view_type { - ANV_ATTACHMENT_VIEW_TYPE_COLOR, - ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL, -}; - -struct anv_attachment_view { - enum anv_attachment_view_type attachment_type; - struct anv_image_view image_view; -}; - struct anv_image_create_info { const VkImageCreateInfo *vk_info; bool force_tile_mode; @@ -1297,17 +1287,17 @@ gen8_image_view_init(struct anv_image_view *iview, const VkImageViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void anv_color_attachment_view_init(struct anv_attachment_view *aview, +void anv_color_attachment_view_init(struct anv_image_view *iview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void gen7_color_attachment_view_init(struct anv_attachment_view *aview, +void gen7_color_attachment_view_init(struct anv_image_view *iview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void gen8_color_attachment_view_init(struct anv_attachment_view *aview, +void gen8_color_attachment_view_init(struct anv_image_view *iview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); @@ -1338,7 +1328,7 @@ struct anv_framebuffer { VkDynamicViewportState vp_state; uint32_t attachment_count; - const struct anv_attachment_view * attachments[0]; + const struct anv_image_view * attachments[0]; }; struct anv_subpass { @@ -1424,7 +1414,6 @@ ANV_DEFINE_HANDLE_CASTS(anv_physical_device, VkPhysicalDevice) ANV_DEFINE_HANDLE_CASTS(anv_queue, VkQueue) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_cmd_pool, VkCmdPool) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_attachment_view, VkAttachmentView) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_buffer, VkBuffer) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_buffer_view, VkBufferView); ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_descriptor_set, VkDescriptorSet) diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index 2b9ed5772e1..709e82e78a0 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -529,9 +529,8 @@ static void gen7_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) { const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; - const struct anv_attachment_view *aview = + const struct anv_image_view *iview = anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); - const struct anv_image_view *iview = aview ? &aview->image_view : NULL; const struct anv_image *image = iview ? iview->image : NULL; const bool has_depth = iview && iview->format->depth_format; const bool has_stencil = iview && iview->format->has_stencil; diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index ed9d9f8c568..1959b8b5a49 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -360,18 +360,15 @@ gen7_image_view_init(struct anv_image_view *iview, } void -gen7_color_attachment_view_init(struct anv_attachment_view *aview, +gen7_color_attachment_view_init(struct anv_image_view *iview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_image_view *iview = &aview->image_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); - aview->attachment_type = ANV_ATTACHMENT_VIEW_TYPE_COLOR; - anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index f48519e51b9..b516193458c 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -458,9 +458,8 @@ static void gen8_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) { const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; - const struct anv_attachment_view *aview = + const struct anv_image_view *iview = anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); - const struct anv_image_view *iview = aview ? &aview->image_view : NULL; const struct anv_image *image = iview ? iview->image : NULL; const bool has_depth = iview && iview->format->depth_format; const bool has_stencil = iview && iview->format->has_stencil; diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 4990becf60a..d2a403b2f56 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -281,13 +281,12 @@ gen8_image_view_init(struct anv_image_view *iview, } void -gen8_color_attachment_view_init(struct anv_attachment_view *aview, +gen8_color_attachment_view_init(struct anv_image_view *iview, struct anv_device *device, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_image_view *iview = &aview->image_view; struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); const struct anv_format *format_info = @@ -296,8 +295,6 @@ gen8_color_attachment_view_init(struct anv_attachment_view *aview, uint32_t depth = 1; /* RENDER_SURFACE_STATE::Depth */ uint32_t rt_view_extent = 1; /* RENDER_SURFACE_STATE::RenderTargetViewExtent */ - aview->attachment_type = ANV_ATTACHMENT_VIEW_TYPE_COLOR; - anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); From 1e4263b7d2e3d6f88527510eaaf6ca6df2ce4058 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:27:50 -0700 Subject: [PATCH 42/76] vk/0.170.2: s/baseArraySlice/baseArrayLayer/ --- include/vulkan/vulkan.h | 4 ++-- src/vulkan/anv_image.c | 6 +++--- src/vulkan/anv_meta.c | 12 ++++++------ src/vulkan/gen7_state.c | 2 +- src/vulkan/gen8_state.c | 2 +- 5 files changed, 13 insertions(+), 13 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 3498b46ab62..90df1cb5a5d 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1397,7 +1397,7 @@ typedef struct { typedef struct { VkImageAspect aspect; uint32_t mipLevel; - uint32_t arraySlice; + uint32_t arrayLayer; } VkImageSubresource; typedef struct { @@ -1496,7 +1496,7 @@ typedef struct { VkImageAspectFlags aspectMask; uint32_t baseMipLevel; uint32_t mipLevels; - uint32_t baseArraySlice; + uint32_t baseArrayLayer; uint32_t arraySize; } VkImageSubresourceRange; diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 8eb5a603c2b..f0620e4d67e 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -411,12 +411,12 @@ anv_validate_CreateImageView(VkDevice _device, assert(subresource->arraySize > 0); assert(subresource->baseMipLevel < image->levels); assert(subresource->baseMipLevel + subresource->mipLevels <= image->levels); - assert(subresource->baseArraySlice < image->array_size); - assert(subresource->baseArraySlice + subresource->arraySize <= image->array_size); + assert(subresource->baseArrayLayer < image->array_size); + assert(subresource->baseArrayLayer + subresource->arraySize <= image->array_size); assert(pView); if (view_info->is_cube) { - assert(subresource->baseArraySlice % 6 == 0); + assert(subresource->baseArrayLayer % 6 == 0); assert(subresource->arraySize % 6 == 0); } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index c214dc30a4c..4abd8d38213 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -1018,7 +1018,7 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0, .mipLevels = 1, - .baseArraySlice = 0, + .baseArrayLayer = 0, .arraySize = 1 }, }, @@ -1166,7 +1166,7 @@ void anv_CmdCopyImage( .aspectMask = 1 << pRegions[r].srcSubresource.aspect, .baseMipLevel = pRegions[r].srcSubresource.mipLevel, .mipLevels = 1, - .baseArraySlice = pRegions[r].srcSubresource.arrayLayer, + .baseArrayLayer = pRegions[r].srcSubresource.arrayLayer, .arraySize = 1 }, }, @@ -1255,7 +1255,7 @@ void anv_CmdBlitImage( .aspectMask = 1 << pRegions[r].srcSubresource.aspect, .baseMipLevel = pRegions[r].srcSubresource.mipLevel, .mipLevels = 1, - .baseArraySlice = pRegions[r].srcSubresource.arrayLayer, + .baseArrayLayer = pRegions[r].srcSubresource.arrayLayer, .arraySize = 1 }, }, @@ -1388,7 +1388,7 @@ void anv_CmdCopyBufferToImage( .aspectMask = 1 << proxy_aspect, .baseMipLevel = 0, .mipLevels = 1, - .baseArraySlice = 0, + .baseArrayLayer = 0, .arraySize = 1 }, }, @@ -1478,7 +1478,7 @@ void anv_CmdCopyImageToBuffer( .aspectMask = 1 << pRegions[r].imageSubresource.aspect, .baseMipLevel = pRegions[r].imageSubresource.mipLevel, .mipLevels = 1, - .baseArraySlice = pRegions[r].imageSubresource.arrayLayer, + .baseArrayLayer = pRegions[r].imageSubresource.arrayLayer, .arraySize = 1 }, }, @@ -1565,7 +1565,7 @@ void anv_CmdClearColorImage( .image = _image, .format = image->format->vk_format, .mipLevel = pRanges[r].baseMipLevel + l, - .baseArraySlice = pRanges[r].baseArraySlice + s, + .baseArraySlice = pRanges[r].baseArrayLayer + s, .arraySize = 1, }, cmd_buffer); diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 1959b8b5a49..d7a4b10c6e8 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -322,7 +322,7 @@ gen7_image_view_init(struct anv_image_view *iview, .Width = image->extent.width - 1, .Depth = depth - 1, .SurfacePitch = surface->stride - 1, - .MinimumArrayElement = range->baseArraySlice, + .MinimumArrayElement = range->baseArrayLayer, .NumberofMultisamples = MULTISAMPLECOUNT_1, .XOffset = 0, .YOffset = 0, diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index d2a403b2f56..e836613db42 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -243,7 +243,7 @@ gen8_image_view_init(struct anv_image_view *iview, .Depth = depth - 1, .SurfacePitch = surface->stride - 1, .RenderTargetViewExtent = rt_view_extent - 1, - .MinimumArrayElement = range->baseArraySlice, + .MinimumArrayElement = range->baseArrayLayer, .NumberofMultisamples = MULTISAMPLECOUNT_1, .XOffset = 0, .YOffset = 0, From 89eebd889cbf1be38648a3812f513051b777aa57 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 10:34:59 -0700 Subject: [PATCH 43/76] vk/0.170.2: Fairly trivial enum shuffling --- include/vulkan/vulkan.h | 20 +++++++++----------- src/vulkan/anv_device.c | 2 +- src/vulkan/gen8_cmd_buffer.c | 3 +-- 3 files changed, 11 insertions(+), 14 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 90df1cb5a5d..ce1d2d88e9f 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -857,12 +857,11 @@ typedef enum { typedef VkFlags VkImageUsageFlags; typedef enum { - VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, } VkImageCreateFlagBits; typedef VkFlags VkImageCreateFlags; @@ -886,7 +885,7 @@ typedef enum { typedef VkFlags VkMemoryPropertyFlags; typedef enum { - VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, + VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, } VkMemoryHeapFlagBits; typedef VkFlags VkMemoryHeapFlags; typedef VkFlags VkMemoryMapFlags; @@ -948,7 +947,7 @@ typedef enum { typedef VkFlags VkBufferUsageFlags; typedef enum { - VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, } VkBufferCreateFlagBits; @@ -1015,10 +1014,9 @@ typedef enum { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, - VK_PIPELINE_STAGE_TRANSITION_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00002000, VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, - VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF, + VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, } VkPipelineStageFlagBits; typedef VkFlags VkPipelineStageFlags; @@ -1052,7 +1050,7 @@ typedef enum { typedef VkFlags VkCmdPoolCreateFlags; typedef enum { - VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001, + VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, } VkCmdPoolResetFlagBits; typedef VkFlags VkCmdPoolResetFlags; typedef VkFlags VkCmdBufferCreateFlags; @@ -1067,7 +1065,7 @@ typedef enum { typedef VkFlags VkCmdBufferOptimizeFlags; typedef enum { - VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001, + VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, } VkCmdBufferResetFlagBits; typedef VkFlags VkCmdBufferResetFlags; diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index a7430b858b5..e7f74266e68 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -495,7 +495,7 @@ VkResult anv_GetPhysicalDeviceMemoryProperties( pMemoryProperties->memoryHeapCount = 1; pMemoryProperties->memoryHeaps[0] = (VkMemoryHeap) { .size = heap_size, - .flags = VK_MEMORY_HEAP_HOST_LOCAL, + .flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT, }; return VK_SUCCESS; diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index b516193458c..1cd4a8561e6 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -935,8 +935,7 @@ void gen8_CmdPipelineBarrier( if (anv_clear_mask(&srcStageMask, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | - VK_PIPELINE_STAGE_TRANSFER_BIT | - VK_PIPELINE_STAGE_TRANSITION_BIT)) { + VK_PIPELINE_STAGE_TRANSFER_BIT)) { cmd.CommandStreamerStallEnable = true; } From ccea9cc332bf3260f065a879e1732e52eacbf94c Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 14:44:38 -0700 Subject: [PATCH 44/76] nir/spirv: Update to SPIR-V Rev. 32 --- src/glsl/nir/spirv.h | 119 +++++++++++++++++++--------- src/glsl/nir/spirv_glsl450.h | 73 ++++++++--------- src/glsl/nir/spirv_glsl450_to_nir.c | 7 +- src/glsl/nir/spirv_to_nir.c | 11 +-- 4 files changed, 124 insertions(+), 86 deletions(-) diff --git a/src/glsl/nir/spirv.h b/src/glsl/nir/spirv.h index d289c687c76..e9e53973801 100644 --- a/src/glsl/nir/spirv.h +++ b/src/glsl/nir/spirv.h @@ -1,20 +1,20 @@ /* ** Copyright (c) 2014-2015 The Khronos Group Inc. -** +** ** Permission is hereby granted, free of charge, to any person obtaining a copy ** of this software and/or associated documentation files (the "Materials"), ** to deal in the Materials without restriction, including without limitation ** the rights to use, copy, modify, merge, publish, distribute, sublicense, ** and/or sell copies of the Materials, and to permit persons to whom the ** Materials are furnished to do so, subject to the following conditions: -** +** ** The above copyright notice and this permission notice shall be included in ** all copies or substantial portions of the Materials. -** +** ** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS ** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND -** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ -** +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL @@ -30,16 +30,16 @@ */ /* -** Specification revision 31. +** Specification revision 33. ** Enumeration tokens for SPIR-V, in various styles: ** C, C++, C++11, JSON, Lua, Python -** +** ** - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL ** - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL ** - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL ** - Lua will use tables, e.g.: spv.SourceLanguage.GLSL ** - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] -** +** ** Some tokens act like mask values, which can be OR'd together, ** while others are mutually exclusive. The mask-like ones have ** "Mask" in their name, and a parallel enum that has the shift @@ -53,7 +53,7 @@ typedef unsigned int SpvId; static const unsigned int SpvMagicNumber = 0x07230203; static const unsigned int SpvVersion = 99; -static const unsigned int SpvRevision = 31; +static const unsigned int SpvRevision = 33; static const unsigned int SpvOpCodeMask = 0xffff; static const unsigned int SpvWordCountShift = 16; @@ -100,7 +100,6 @@ typedef enum SpvExecutionMode_ { SpvExecutionModePointMode = 10, SpvExecutionModeXfb = 11, SpvExecutionModeDepthReplacing = 12, - SpvExecutionModeDepthAny = 13, SpvExecutionModeDepthGreater = 14, SpvExecutionModeDepthLess = 15, SpvExecutionModeDepthUnchanged = 16, @@ -119,6 +118,7 @@ typedef enum SpvExecutionMode_ { SpvExecutionModeOutputTriangleStrip = 29, SpvExecutionModeVecTypeHint = 30, SpvExecutionModeContractionOff = 31, + SpvExecutionModeIndependentForwardProgress = 32, } SpvExecutionMode; typedef enum SpvStorageClass_ { @@ -131,6 +131,7 @@ typedef enum SpvStorageClass_ { SpvStorageClassPrivateGlobal = 6, SpvStorageClassFunction = 7, SpvStorageClassGeneric = 8, + SpvStorageClassPushConstant = 9, SpvStorageClassAtomicCounter = 10, SpvStorageClassImage = 11, } SpvStorageClass; @@ -142,6 +143,7 @@ typedef enum SpvDim_ { SpvDimCube = 3, SpvDimRect = 4, SpvDimBuffer = 5, + SpvDimInputTarget = 6, } SpvDim; typedef enum SpvSamplerAddressingMode_ { @@ -249,6 +251,7 @@ typedef enum SpvImageOperandsShift_ { SpvImageOperandsOffsetShift = 4, SpvImageOperandsConstOffsetsShift = 5, SpvImageOperandsSampleShift = 6, + SpvImageOperandsMinLodShift = 7, } SpvImageOperandsShift; typedef enum SpvImageOperandsMask_ { @@ -260,6 +263,7 @@ typedef enum SpvImageOperandsMask_ { SpvImageOperandsOffsetMask = 0x00000010, SpvImageOperandsConstOffsetsMask = 0x00000020, SpvImageOperandsSampleMask = 0x00000040, + SpvImageOperandsMinLodMask = 0x00000080, } SpvImageOperandsMask; typedef enum SpvFPFastMathModeShift_ { @@ -322,7 +326,7 @@ typedef enum SpvDecoration_ { SpvDecorationCPacked = 10, SpvDecorationBuiltIn = 11, SpvDecorationSmooth = 12, - SpvDecorationNoperspective = 13, + SpvDecorationNoPerspective = 13, SpvDecorationFlat = 14, SpvDecorationPatch = 15, SpvDecorationCentroid = 16, @@ -333,10 +337,9 @@ typedef enum SpvDecoration_ { SpvDecorationVolatile = 21, SpvDecorationConstant = 22, SpvDecorationCoherent = 23, - SpvDecorationNonwritable = 24, - SpvDecorationNonreadable = 25, + SpvDecorationNonWritable = 24, + SpvDecorationNonReadable = 25, SpvDecorationUniform = 26, - SpvDecorationNoStaticUse = 27, SpvDecorationSaturatedConversion = 28, SpvDecorationStream = 29, SpvDecorationLocation = 30, @@ -351,6 +354,9 @@ typedef enum SpvDecoration_ { SpvDecorationFPRoundingMode = 39, SpvDecorationFPFastMathMode = 40, SpvDecorationLinkageAttributes = 41, + SpvDecorationNoContraction = 42, + SpvDecorationInputTargetIndex = 43, + SpvDecorationAlignment = 44, } SpvDecoration; typedef enum SpvBuiltIn_ { @@ -395,6 +401,8 @@ typedef enum SpvBuiltIn_ { SpvBuiltInNumEnqueuedSubgroups = 39, SpvBuiltInSubgroupId = 40, SpvBuiltInSubgroupLocalInvocationId = 41, + SpvBuiltInVertexIndex = 42, + SpvBuiltInInstanceIndex = 43, } SpvBuiltIn; typedef enum SpvSelectionControlShift_ { @@ -435,41 +443,43 @@ typedef enum SpvFunctionControlMask_ { } SpvFunctionControlMask; typedef enum SpvMemorySemanticsShift_ { - SpvMemorySemanticsRelaxedShift = 0, - SpvMemorySemanticsSequentiallyConsistentShift = 1, - SpvMemorySemanticsAcquireShift = 2, - SpvMemorySemanticsReleaseShift = 3, - SpvMemorySemanticsUniformMemoryShift = 4, - SpvMemorySemanticsSubgroupMemoryShift = 5, - SpvMemorySemanticsWorkgroupLocalMemoryShift = 6, - SpvMemorySemanticsWorkgroupGlobalMemoryShift = 7, - SpvMemorySemanticsAtomicCounterMemoryShift = 8, - SpvMemorySemanticsImageMemoryShift = 9, + SpvMemorySemanticsAcquireShift = 1, + SpvMemorySemanticsReleaseShift = 2, + SpvMemorySemanticsAcquireReleaseShift = 3, + SpvMemorySemanticsSequentiallyConsistentShift = 4, + SpvMemorySemanticsUniformMemoryShift = 6, + SpvMemorySemanticsSubgroupMemoryShift = 7, + SpvMemorySemanticsWorkgroupLocalMemoryShift = 8, + SpvMemorySemanticsWorkgroupGlobalMemoryShift = 9, + SpvMemorySemanticsAtomicCounterMemoryShift = 10, + SpvMemorySemanticsImageMemoryShift = 11, } SpvMemorySemanticsShift; typedef enum SpvMemorySemanticsMask_ { SpvMemorySemanticsMaskNone = 0, - SpvMemorySemanticsRelaxedMask = 0x00000001, - SpvMemorySemanticsSequentiallyConsistentMask = 0x00000002, - SpvMemorySemanticsAcquireMask = 0x00000004, - SpvMemorySemanticsReleaseMask = 0x00000008, - SpvMemorySemanticsUniformMemoryMask = 0x00000010, - SpvMemorySemanticsSubgroupMemoryMask = 0x00000020, - SpvMemorySemanticsWorkgroupLocalMemoryMask = 0x00000040, - SpvMemorySemanticsWorkgroupGlobalMemoryMask = 0x00000080, - SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000100, - SpvMemorySemanticsImageMemoryMask = 0x00000200, + SpvMemorySemanticsAcquireMask = 0x00000002, + SpvMemorySemanticsReleaseMask = 0x00000004, + SpvMemorySemanticsAcquireReleaseMask = 0x00000008, + SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010, + SpvMemorySemanticsUniformMemoryMask = 0x00000040, + SpvMemorySemanticsSubgroupMemoryMask = 0x00000080, + SpvMemorySemanticsWorkgroupLocalMemoryMask = 0x00000100, + SpvMemorySemanticsWorkgroupGlobalMemoryMask = 0x00000200, + SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400, + SpvMemorySemanticsImageMemoryMask = 0x00000800, } SpvMemorySemanticsMask; typedef enum SpvMemoryAccessShift_ { SpvMemoryAccessVolatileShift = 0, SpvMemoryAccessAlignedShift = 1, + SpvMemoryAccessNontemporalShift = 2, } SpvMemoryAccessShift; typedef enum SpvMemoryAccessMask_ { SpvMemoryAccessMaskNone = 0, SpvMemoryAccessVolatileMask = 0x00000001, SpvMemoryAccessAlignedMask = 0x00000002, + SpvMemoryAccessNontemporalMask = 0x00000004, } SpvMemoryAccessMask; typedef enum SpvScope_ { @@ -538,11 +548,30 @@ typedef enum SpvCapability_ { SpvCapabilityCullDistance = 33, SpvCapabilityImageCubeArray = 34, SpvCapabilitySampleRateShading = 35, + SpvCapabilityImageRect = 36, + SpvCapabilitySampledRect = 37, + SpvCapabilityGenericPointer = 38, + SpvCapabilityInt8 = 39, + SpvCapabilityInputTarget = 40, + SpvCapabilitySparseResidency = 41, + SpvCapabilityMinLod = 42, + SpvCapabilitySampled1D = 43, + SpvCapabilityImage1D = 44, + SpvCapabilitySampledCubeArray = 45, + SpvCapabilitySampledBuffer = 46, + SpvCapabilityImageBuffer = 47, + SpvCapabilityImageMSArray = 48, + SpvCapabilityAdvancedFormats = 49, + SpvCapabilityImageQuery = 50, + SpvCapabilityDerivativeControl = 51, + SpvCapabilityInterpolationFunction = 52, + SpvCapabilityTransformFeedback = 53, } SpvCapability; typedef enum SpvOp_ { SpvOpNop = 0, SpvOpUndef = 1, + SpvOpSourceContinued = 2, SpvOpSource = 3, SpvOpSourceExtension = 4, SpvOpName = 5, @@ -576,6 +605,7 @@ typedef enum SpvOp_ { SpvOpTypeReserveId = 36, SpvOpTypeQueue = 37, SpvOpTypePipe = 38, + SpvOpTypeForwardPointer = 39, SpvOpConstantTrue = 41, SpvOpConstantFalse = 42, SpvOpConstant = 43, @@ -602,6 +632,7 @@ typedef enum SpvOp_ { SpvOpPtrAccessChain = 67, SpvOpArrayLength = 68, SpvOpGenericPtrMemSemantics = 69, + SpvOpInBoundsPtrAccessChain = 70, SpvOpDecorate = 71, SpvOpMemberDecorate = 72, SpvOpDecorationGroup = 73, @@ -629,7 +660,6 @@ typedef enum SpvOp_ { SpvOpImageDrefGather = 97, SpvOpImageRead = 98, SpvOpImageWrite = 99, - SpvOpImageQueryDim = 100, SpvOpImageQueryFormat = 101, SpvOpImageQueryOrder = 102, SpvOpImageQuerySizeLod = 103, @@ -678,7 +708,8 @@ typedef enum SpvOp_ { SpvOpDot = 148, SpvOpIAddCarry = 149, SpvOpISubBorrow = 150, - SpvOpIMulExtended = 151, + SpvOpUMulExtended = 151, + SpvOpSMulExtended = 152, SpvOpAny = 154, SpvOpAll = 155, SpvOpIsNan = 156, @@ -815,6 +846,22 @@ typedef enum SpvOp_ { SpvOpCaptureEventProfilingInfo = 302, SpvOpGetDefaultQueue = 303, SpvOpBuildNDRange = 304, + SpvOpImageSparseSampleImplicitLod = 305, + SpvOpImageSparseSampleExplicitLod = 306, + SpvOpImageSparseSampleDrefImplicitLod = 307, + SpvOpImageSparseSampleDrefExplicitLod = 308, + SpvOpImageSparseSampleProjImplicitLod = 309, + SpvOpImageSparseSampleProjExplicitLod = 310, + SpvOpImageSparseSampleProjDrefImplicitLod = 311, + SpvOpImageSparseSampleProjDrefExplicitLod = 312, + SpvOpImageSparseFetch = 313, + SpvOpImageSparseGather = 314, + SpvOpImageSparseDrefGather = 315, + SpvOpImageSparseTexelsResident = 316, + SpvOpNoLine = 317, + SpvOpAtomicFlagTestAndSet = 318, + SpvOpAtomicFlagClear = 319, } SpvOp; #endif // #ifndef spirv_H + diff --git a/src/glsl/nir/spirv_glsl450.h b/src/glsl/nir/spirv_glsl450.h index d828b152f43..d1c9b5c1d44 100644 --- a/src/glsl/nir/spirv_glsl450.h +++ b/src/glsl/nir/spirv_glsl450.h @@ -13,7 +13,7 @@ ** ** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS ** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND -** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ +** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, @@ -28,7 +28,7 @@ #define GLSLstd450_H const int GLSLstd450Version = 99; -const int GLSLstd450Revision = 2; +const int GLSLstd450Revision = 3; enum GLSLstd450 { GLSLstd450Bad = 0, // Don't use @@ -82,47 +82,44 @@ enum GLSLstd450 { GLSLstd450FClamp = 43, GLSLstd450UClamp = 44, GLSLstd450SClamp = 45, - GLSLstd450Mix = 46, - GLSLstd450Step = 47, - GLSLstd450SmoothStep = 48, + GLSLstd450FMix = 46, + GLSLstd450IMix = 47, + GLSLstd450Step = 48, + GLSLstd450SmoothStep = 49, - GLSLstd450Fma = 49, - GLSLstd450Frexp = 50, // second operand needs an OpVariable to write to - GLSLstd450FrexpStruct = 51, // no OpVariable operand - GLSLstd450Ldexp = 52, + GLSLstd450Fma = 50, + GLSLstd450Frexp = 51, // second operand needs an OpVariable to write to + GLSLstd450FrexpStruct = 52, // no OpVariable operand + GLSLstd450Ldexp = 53, - GLSLstd450PackSnorm4x8 = 53, - GLSLstd450PackUnorm4x8 = 54, - GLSLstd450PackSnorm2x16 = 55, - GLSLstd450PackUnorm2x16 = 56, - GLSLstd450PackHalf2x16 = 57, - GLSLstd450PackDouble2x32 = 58, - GLSLstd450UnpackSnorm2x16 = 59, - GLSLstd450UnpackUnorm2x16 = 60, - GLSLstd450UnpackHalf2x16 = 61, - GLSLstd450UnpackSnorm4x8 = 62, - GLSLstd450UnpackUnorm4x8 = 63, - GLSLstd450UnpackDouble2x32 = 64, + GLSLstd450PackSnorm4x8 = 54, + GLSLstd450PackUnorm4x8 = 55, + GLSLstd450PackSnorm2x16 = 56, + GLSLstd450PackUnorm2x16 = 57, + GLSLstd450PackHalf2x16 = 58, + GLSLstd450PackDouble2x32 = 59, + GLSLstd450UnpackSnorm2x16 = 60, + GLSLstd450UnpackUnorm2x16 = 61, + GLSLstd450UnpackHalf2x16 = 62, + GLSLstd450UnpackSnorm4x8 = 63, + GLSLstd450UnpackUnorm4x8 = 64, + GLSLstd450UnpackDouble2x32 = 65, - GLSLstd450Length = 65, - GLSLstd450Distance = 66, - GLSLstd450Cross = 67, - GLSLstd450Normalize = 68, - GLSLstd450FaceForward = 69, - GLSLstd450Reflect = 70, - GLSLstd450Refract = 71, + GLSLstd450Length = 66, + GLSLstd450Distance = 67, + GLSLstd450Cross = 68, + GLSLstd450Normalize = 69, + GLSLstd450FaceForward = 70, + GLSLstd450Reflect = 71, + GLSLstd450Refract = 72, - GLSLstd450FindILSB = 72, - GLSLstd450FindSMSB = 73, - GLSLstd450FindUMSB = 74, + GLSLstd450FindILsb = 73, + GLSLstd450FindSMsb = 74, + GLSLstd450FindUMsb = 75, - GLSLstd450InterpolateAtCentroid = 75, - GLSLstd450InterpolateAtSample = 76, - GLSLstd450InterpolateAtOffset = 77, - - GLSLstd450AddCarry = 78, // These three should move to the core instruction set - GLSLstd450SubBorrow = 79, - GLSLstd450MulExtended = 80, + GLSLstd450InterpolateAtCentroid = 76, + GLSLstd450InterpolateAtSample = 77, + GLSLstd450InterpolateAtOffset = 78, GLSLstd450Count }; diff --git a/src/glsl/nir/spirv_glsl450_to_nir.c b/src/glsl/nir/spirv_glsl450_to_nir.c index 60bd597820c..1056c0f1ddf 100644 --- a/src/glsl/nir/spirv_glsl450_to_nir.c +++ b/src/glsl/nir/spirv_glsl450_to_nir.c @@ -86,7 +86,7 @@ handle_glsl450_alu(struct vtn_builder *b, enum GLSLstd450 entrypoint, case GLSLstd450Modf: op = nir_op_fmod; break; case GLSLstd450FMin: op = nir_op_fmin; break; case GLSLstd450FMax: op = nir_op_fmax; break; - case GLSLstd450Mix: op = nir_op_flrp; break; + case GLSLstd450FMix: op = nir_op_flrp; break; case GLSLstd450Step: val->ssa->def = nir_sge(&b->nb, src[1], src[0]); return; @@ -116,9 +116,6 @@ handle_glsl450_alu(struct vtn_builder *b, enum GLSLstd450 entrypoint, val->ssa->def = nir_fdiv(&b->nb, src[0], build_length(&b->nb, src[0])); return; - case GLSLstd450AddCarry: op = nir_op_uadd_carry; break; - case GLSLstd450SubBorrow: op = nir_op_usub_borrow; break; - case GLSLstd450Exp: case GLSLstd450Log: case GLSLstd450FClamp: @@ -142,7 +139,7 @@ handle_glsl450_alu(struct vtn_builder *b, enum GLSLstd450 entrypoint, case GLSLstd450FaceForward: case GLSLstd450Reflect: case GLSLstd450Refract: - case GLSLstd450MulExtended: + case GLSLstd450IMix: default: unreachable("Unhandled opcode"); } diff --git a/src/glsl/nir/spirv_to_nir.c b/src/glsl/nir/spirv_to_nir.c index 45053a6c937..e4035f222a6 100644 --- a/src/glsl/nir/spirv_to_nir.c +++ b/src/glsl/nir/spirv_to_nir.c @@ -340,7 +340,7 @@ struct_member_decoration_cb(struct vtn_builder *b, case SpvDecorationSmooth: ctx->fields[member].interpolation = INTERP_QUALIFIER_SMOOTH; break; - case SpvDecorationNoperspective: + case SpvDecorationNoPerspective: ctx->fields[member].interpolation = INTERP_QUALIFIER_NOPERSPECTIVE; break; case SpvDecorationFlat: @@ -740,7 +740,7 @@ var_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member, case SpvDecorationSmooth: var->data.interpolation = INTERP_QUALIFIER_SMOOTH; break; - case SpvDecorationNoperspective: + case SpvDecorationNoPerspective: var->data.interpolation = INTERP_QUALIFIER_NOPERSPECTIVE; break; case SpvDecorationFlat: @@ -759,7 +759,7 @@ var_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member, assert(var->constant_initializer != NULL); var->data.read_only = true; break; - case SpvDecorationNonwritable: + case SpvDecorationNonWritable: var->data.read_only = true; break; case SpvDecorationLocation: @@ -790,9 +790,6 @@ var_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member, b->builtins[dec->literals[0]] = var; break; } - case SpvDecorationNoStaticUse: - /* This can safely be ignored */ - break; case SpvDecorationRowMajor: case SpvDecorationColMajor: case SpvDecorationGLSLShared: @@ -801,7 +798,7 @@ var_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member, case SpvDecorationAliased: case SpvDecorationVolatile: case SpvDecorationCoherent: - case SpvDecorationNonreadable: + case SpvDecorationNonReadable: case SpvDecorationUniform: /* This is really nice but we have no use for it right now. */ case SpvDecorationCPacked: From c272bb58f5cded827b8a4c94a419504f8ff4cc9e Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 15:10:45 -0700 Subject: [PATCH 45/76] nir/spirv: Better texture handling --- src/glsl/nir/spirv_to_nir.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/glsl/nir/spirv_to_nir.c b/src/glsl/nir/spirv_to_nir.c index e4035f222a6..d0fb6a255a5 100644 --- a/src/glsl/nir/spirv_to_nir.c +++ b/src/glsl/nir/spirv_to_nir.c @@ -1508,7 +1508,7 @@ static nir_tex_src vtn_tex_src(struct vtn_builder *b, unsigned index, nir_tex_src_type type) { nir_tex_src src; - src.src = nir_src_for_ssa(vtn_value(b, index, vtn_value_type_ssa)->ssa->def); + src.src = nir_src_for_ssa(vtn_ssa_value(b, index)->def); src.src_type = type; return src; } @@ -1568,16 +1568,19 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp opcode, nir_texop texop; switch (opcode) { case SpvOpImageSampleImplicitLod: - case SpvOpImageSampleExplicitLod: case SpvOpImageSampleDrefImplicitLod: - case SpvOpImageSampleDrefExplicitLod: case SpvOpImageSampleProjImplicitLod: - case SpvOpImageSampleProjExplicitLod: case SpvOpImageSampleProjDrefImplicitLod: - case SpvOpImageSampleProjDrefExplicitLod: texop = nir_texop_tex; break; + case SpvOpImageSampleExplicitLod: + case SpvOpImageSampleDrefExplicitLod: + case SpvOpImageSampleProjExplicitLod: + case SpvOpImageSampleProjDrefExplicitLod: + texop = nir_texop_txl; + break; + case SpvOpImageFetch: texop = nir_texop_txf; break; @@ -1616,8 +1619,8 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp opcode, } if (operands & SpvImageOperandsLodMask) { - assert(texop == nir_texop_tex); - texop = nir_texop_txl; + assert(texop == nir_texop_txl || texop == nir_texop_txf || + texop == nir_texop_txs); (*p++) = vtn_tex_src(b, w[idx++], nir_tex_src_lod); } From d00718104f956783291fbfc28f9d0a2e9bee4003 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 18:18:47 -0700 Subject: [PATCH 46/76] vk/image: Remove stale anv_asserts for depthstencil attachments We don't fully handle mipmapped, array depthstencil attachments. But we handle the well enough for Crucible's miptree tests. --- src/vulkan/anv_image.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index f0620e4d67e..29a442daa43 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -506,11 +506,6 @@ anv_depth_stencil_view_init(struct anv_image_view *iview, { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - /* XXX: We don't handle any of these */ - anv_assert(pCreateInfo->mipLevel == 0); - anv_assert(pCreateInfo->baseArraySlice == 0); - anv_assert(pCreateInfo->arraySize == 1); - iview->image = image; iview->format = anv_format_for_vk_format(pCreateInfo->format); From cf603714cb0e2e5c5dfe7309b8938c910933aafa Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 18:34:37 -0700 Subject: [PATCH 47/76] vk/meta: Fix usage flags for image-wrapped-buffers In make_image_for_buffer(), use VK_IMAGE_USAGE_SAMPLED_BIT when transferring from the buffer and use VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT when transferring to the buffer. --- src/vulkan/anv_meta.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 4abd8d38213..7646071276a 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -1304,6 +1304,7 @@ void anv_CmdBlitImage( static VkImage make_image_for_buffer(VkDevice vk_device, VkBuffer vk_buffer, VkFormat format, + VkImageUsageFlags usage, const VkBufferImageCopy *copy) { ANV_FROM_HANDLE(anv_buffer, buffer, vk_buffer); @@ -1326,7 +1327,7 @@ make_image_for_buffer(VkDevice vk_device, VkBuffer vk_buffer, VkFormat format, .arraySize = 1, .samples = 1, .tiling = VK_IMAGE_TILING_LINEAR, - .usage = VK_IMAGE_USAGE_SAMPLED_BIT, + .usage = usage, .flags = 0, }, &vk_image); assert(result == VK_SUCCESS); @@ -1368,8 +1369,7 @@ void anv_CmdCopyBufferToImage( } VkImage srcImage = make_image_for_buffer(vk_device, srcBuffer, - proxy_format, - &pRegions[r]); + proxy_format, VK_IMAGE_USAGE_SAMPLED_BIT, &pRegions[r]); struct anv_image_view src_iview; anv_image_view_init(&src_iview, cmd_buffer->device, @@ -1490,8 +1490,7 @@ void anv_CmdCopyImageToBuffer( } VkImage destImage = make_image_for_buffer(vk_device, destBuffer, - dest_format, - &pRegions[r]); + dest_format, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &pRegions[r]); struct anv_image_view dest_iview; anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, From 44143a1f4658143b8acc4aaf515603f9507442f1 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 18:17:09 -0700 Subject: [PATCH 48/76] vk: Add anv_image::usage It's a copy of VkImageCreateInfo::usage. Will be used for the VkAttachmentView/VkImageView merge. --- src/vulkan/anv_image.c | 24 ++++++++++++++++++++++++ src/vulkan/anv_private.h | 1 + src/vulkan/gen7_state.c | 1 + src/vulkan/gen8_state.c | 1 + 4 files changed, 27 insertions(+) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 29a442daa43..b95cadca9e7 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -304,8 +304,21 @@ anv_image_create(VkDevice _device, image->format = anv_format_for_vk_format(pCreateInfo->format); image->levels = pCreateInfo->mipLevels; image->array_size = pCreateInfo->arraySize; + image->usage = pCreateInfo->usage; image->surf_type = surf_type; + if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT) { + /* Meta will transfer from the image by binding it as a texture. */ + image->usage |= VK_IMAGE_USAGE_SAMPLED_BIT; + } + + if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) { + /* Meta will transfer to the image by binding it as a color attachment, + * even if the image format is not a color format. + */ + image->usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + } + if (likely(anv_format_is_color(image->format))) { r = anv_image_make_surface(create_info, image->format, &image->size, &image->alignment, @@ -458,6 +471,11 @@ anv_image_view_init(struct anv_image_view *iview, const VkImageViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { + ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); + + assert(image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_STORAGE_BIT)); + switch (device->info.gen) { case 7: gen7_image_view_init(iview, device, pCreateInfo, cmd_buffer); @@ -506,6 +524,8 @@ anv_depth_stencil_view_init(struct anv_image_view *iview, { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); + assert(image->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT); + iview->image = image; iview->format = anv_format_for_vk_format(pCreateInfo->format); @@ -565,6 +585,10 @@ anv_color_attachment_view_init(struct anv_image_view *iview, const VkAttachmentViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer) { + ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); + + assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); + switch (device->info.gen) { case 7: gen7_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer); diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 3326625ebb3..06ab1dc65a6 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1202,6 +1202,7 @@ struct anv_image { VkExtent3D extent; uint32_t levels; uint32_t array_size; + VkImageUsageFlags usage; /**< VkImageCreateInfo::usage */ VkDeviceSize size; uint32_t alignment; diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index d7a4b10c6e8..5829d03d3e3 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -369,6 +369,7 @@ gen7_color_attachment_view_init(struct anv_image_view *iview, struct anv_surface *surface = anv_image_get_surface_for_color_attachment(image); + assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index e836613db42..3c479e1c23e 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -295,6 +295,7 @@ gen8_color_attachment_view_init(struct anv_image_view *iview, uint32_t depth = 1; /* RENDER_SURFACE_STATE::Depth */ uint32_t rt_view_extent = 1; /* RENDER_SURFACE_STATE::RenderTargetViewExtent */ + assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); anv_assert(pCreateInfo->arraySize > 0); anv_assert(pCreateInfo->mipLevel < image->levels); anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); From 3fc2b1f32540ee8c3fa994814b69568c64c74d81 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 18:53:29 -0700 Subject: [PATCH 49/76] vk: Remove stale finishme for stencil image views They don't work completely. But they work well enough to satisfy Crucible. --- src/vulkan/anv_image.c | 1 - src/vulkan/anv_meta.c | 8 ++++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index b95cadca9e7..2b3c444428f 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -545,7 +545,6 @@ anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlag return &image->depth_surface; case VK_IMAGE_ASPECT_STENCIL_BIT: assert(image->format->has_stencil); - anv_finishme("stencil image views"); return &image->stencil_surface; case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT: /* FINISHME: The Vulkan spec (git a511ba2) requires support for combined diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index 7646071276a..d69863b8375 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -985,12 +985,16 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, .arraySize = 1, .samples = 1, .tiling = VK_IMAGE_TILING_LINEAR, - .usage = VK_IMAGE_USAGE_SAMPLED_BIT, + .usage = 0, .flags = 0, }; - VkImage src_image, dest_image; + VkImage src_image; + image_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; anv_CreateImage(vk_device, &image_info, &src_image); + + VkImage dest_image; + image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; anv_CreateImage(vk_device, &image_info, &dest_image); /* We could use a vk call to bind memory, but that would require From 37bf120930aa9e3ccf455efc633f2edbdec9dfc1 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 18:55:16 -0700 Subject: [PATCH 50/76] vk/pipeline: Emit MSAA finishme only if samples > 1 If samples == 1, then there's nothing for Mesa to do, and the finishme message is only noise. --- src/vulkan/anv_pipeline.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/vulkan/anv_pipeline.c b/src/vulkan/anv_pipeline.c index 4af4b663c87..192a4b17ae0 100644 --- a/src/vulkan/anv_pipeline.c +++ b/src/vulkan/anv_pipeline.c @@ -209,7 +209,8 @@ anv_pipeline_init(struct anv_pipeline *pipeline, struct anv_device *device, anv_finishme("VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"); if (pCreateInfo->pViewportState) anv_finishme("VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"); - if (pCreateInfo->pMultisampleState) + if (pCreateInfo->pMultisampleState && + pCreateInfo->pMultisampleState->rasterSamples > 1) anv_finishme("VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"); pipeline->use_repclear = extra && extra->use_repclear; From 24de3d49eab3c8fd8aad3f4aeb8aac0154690374 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Tue, 6 Oct 2015 19:11:58 -0700 Subject: [PATCH 51/76] vk: Embed two surface states in anv_image_view This prepares for merging VkAttachmentView into VkImageView. The two surface states are: anv_image_view::color_rt_surface_state: RENDER_SURFACE_STATE when using image as a color render target. anv_image_view::nonrt_surface_state; RENDER_SURFACE_STATE when using image as a non render target. No Crucible regressions. --- src/vulkan/anv_cmd_buffer.c | 6 +- src/vulkan/anv_image.c | 199 ++++++++++++++++++++---------------- src/vulkan/anv_meta.c | 138 ++++++++++++++++++------- src/vulkan/anv_private.h | 33 ++---- src/vulkan/gen7_state.c | 140 ++++++++----------------- src/vulkan/gen8_state.c | 185 ++++++++------------------------- 6 files changed, 309 insertions(+), 392 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 470ea11df6f..7587f2ed103 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -434,8 +434,8 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, const struct anv_image_view *iview = fb->attachments[subpass->color_attachments[a]]; - bt_map[a] = iview->surface_state.offset + state_offset; - add_surface_state_reloc(cmd_buffer, iview->surface_state, + bt_map[a] = iview->color_rt_surface_state.offset + state_offset; + add_surface_state_reloc(cmd_buffer, iview->color_rt_surface_state, iview->bo, iview->offset); } @@ -468,7 +468,7 @@ anv_cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer, bo_offset = desc->buffer_view->offset; break; case ANV_DESCRIPTOR_TYPE_IMAGE_VIEW: - surface_state = &desc->image_view->surface_state; + surface_state = &desc->image_view->nonrt_surface_state; bo = desc->image_view->bo; bo_offset = desc->image_view->offset; break; diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 2b3c444428f..3f4d9b15c92 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -45,7 +45,6 @@ static const uint8_t anv_surf_type_from_image_type[] = { [VK_IMAGE_TYPE_1D] = SURFTYPE_1D, [VK_IMAGE_TYPE_2D] = SURFTYPE_2D, [VK_IMAGE_TYPE_3D] = SURFTYPE_3D, - }; static const struct anv_image_view_info @@ -259,6 +258,26 @@ anv_image_make_surface(const struct anv_image_create_info *create_info, return VK_SUCCESS; } +static VkImageUsageFlags +anv_image_get_full_usage(const VkImageCreateInfo *info) +{ + VkImageUsageFlags usage = info->usage; + + if (usage & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT) { + /* Meta will transfer from the image by binding it as a texture. */ + usage |= VK_IMAGE_USAGE_SAMPLED_BIT; + } + + if (usage & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) { + /* Meta will transfer to the image by binding it as a color attachment, + * even if the image format is not a color format. + */ + usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + } + + return usage; +} + VkResult anv_image_create(VkDevice _device, const struct anv_image_create_info *create_info, @@ -304,19 +323,16 @@ anv_image_create(VkDevice _device, image->format = anv_format_for_vk_format(pCreateInfo->format); image->levels = pCreateInfo->mipLevels; image->array_size = pCreateInfo->arraySize; - image->usage = pCreateInfo->usage; - image->surf_type = surf_type; + image->usage = anv_image_get_full_usage(pCreateInfo); + image->surface_type = surf_type; - if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT) { - /* Meta will transfer from the image by binding it as a texture. */ - image->usage |= VK_IMAGE_USAGE_SAMPLED_BIT; + if (image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_STORAGE_BIT)) { + image->needs_nonrt_surface_state = true; } - if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) { - /* Meta will transfer to the image by binding it as a color attachment, - * even if the image format is not a color format. - */ - image->usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + if (image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { + image->needs_color_rt_surface_state = true; } if (likely(anv_format_is_color(image->format))) { @@ -472,9 +488,27 @@ anv_image_view_init(struct anv_image_view *iview, struct anv_cmd_buffer *cmd_buffer) { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); + const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; + assert(range->arraySize > 0); + assert(range->baseMipLevel < image->levels); assert(image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT | - VK_IMAGE_USAGE_STORAGE_BIT)); + VK_IMAGE_USAGE_STORAGE_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | + VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)); + + switch (image->type) { + default: + unreachable("bad VkImageType"); + case VK_IMAGE_TYPE_1D: + case VK_IMAGE_TYPE_2D: + assert(range->baseArrayLayer + range->arraySize - 1 <= image->array_size); + break; + case VK_IMAGE_TYPE_3D: + assert(range->baseArrayLayer + range->arraySize - 1 + <= anv_minify(image->extent.depth, range->baseMipLevel)); + break; + } switch (device->info.gen) { case 7: @@ -508,29 +542,30 @@ anv_CreateImageView(VkDevice _device, return VK_SUCCESS; } +static void +anv_image_view_destroy(struct anv_device *device, + struct anv_image_view *iview) +{ + if (iview->image->needs_color_rt_surface_state) { + anv_state_pool_free(&device->surface_state_pool, + iview->color_rt_surface_state); + } + + if (iview->image->needs_nonrt_surface_state) { + anv_state_pool_free(&device->surface_state_pool, + iview->nonrt_surface_state); + } + + anv_device_free(device, iview); +} + void anv_DestroyImageView(VkDevice _device, VkImageView _iview) { ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_image_view, iview, _iview); - anv_state_pool_free(&device->surface_state_pool, iview->surface_state); - anv_device_free(device, iview); -} - -static void -anv_depth_stencil_view_init(struct anv_image_view *iview, - const VkAttachmentViewCreateInfo *pCreateInfo) -{ - ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - - assert(image->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT); - - iview->image = image; - iview->format = anv_format_for_vk_format(pCreateInfo->format); - - assert(anv_format_is_depth_or_stencil(image->format)); - assert(anv_format_is_depth_or_stencil(iview->format)); + anv_image_view_destroy(device, iview); } struct anv_surface * @@ -538,8 +573,22 @@ anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlag { switch (aspect_mask) { case VK_IMAGE_ASPECT_COLOR_BIT: - assert(anv_format_is_color(image->format)); - return &image->color_surface; + /* Dragons will eat you. + * + * Meta attaches all destination surfaces as color render targets. Guess + * what surface the Meta Dragons really want. + */ + if (image->format->depth_format && image->format->has_stencil) { + anv_finishme("combined depth stencil formats"); + return &image->depth_surface; + } else if (image->format->depth_format) { + return &image->depth_surface; + } else if (image->format->has_stencil) { + return &image->stencil_surface; + } else { + return &image->color_surface; + } + break; case VK_IMAGE_ASPECT_DEPTH_BIT: assert(image->format->depth_format); return &image->depth_surface; @@ -562,67 +611,52 @@ anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlag } } -/** The attachment may be a color view into a non-color image. */ -struct anv_surface * -anv_image_get_surface_for_color_attachment(struct anv_image *image) -{ - if (anv_format_is_color(image->format)) { - return &image->color_surface; - } else if (image->format->depth_format) { - return &image->depth_surface; - } else if (image->format->has_stencil) { - return &image->stencil_surface; - } else { - unreachable("image has bad format"); - return NULL; - } -} - -void -anv_color_attachment_view_init(struct anv_image_view *iview, - struct anv_device *device, - const VkAttachmentViewCreateInfo* pCreateInfo, - struct anv_cmd_buffer *cmd_buffer) -{ - ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - - assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); - - switch (device->info.gen) { - case 7: - gen7_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer); - break; - case 8: - gen8_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer); - break; - default: - unreachable("unsupported gen\n"); - } -} - VkResult anv_CreateAttachmentView(VkDevice _device, - const VkAttachmentViewCreateInfo *pCreateInfo, + const VkAttachmentViewCreateInfo *info, VkAttachmentView *pView) { ANV_FROM_HANDLE(anv_device, device, _device); struct anv_image_view *iview; - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO); + assert(info->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO); iview = anv_device_alloc(device, sizeof(*iview), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); if (iview == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - const struct anv_format *format = - anv_format_for_vk_format(pCreateInfo->format); + const struct anv_format *format = anv_format_for_vk_format(info->format); - if (anv_format_is_depth_or_stencil(format)) { - anv_depth_stencil_view_init(iview, pCreateInfo); - } else { - anv_color_attachment_view_init(iview, device, pCreateInfo, NULL); - } + VkImageAspectFlags aspect_mask = 0; + if (format->depth_format) + aspect_mask |= VK_IMAGE_ASPECT_DEPTH_BIT; + if (format->has_stencil) + aspect_mask |= VK_IMAGE_ASPECT_STENCIL_BIT; + if (!aspect_mask) + aspect_mask |= VK_IMAGE_ASPECT_COLOR_BIT; + + anv_image_view_init(iview, device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + .image = info->image, + .viewType = VK_IMAGE_VIEW_TYPE_2D, + .format = info->format, + .channels = { + .r = VK_CHANNEL_SWIZZLE_R, + .g = VK_CHANNEL_SWIZZLE_G, + .b = VK_CHANNEL_SWIZZLE_B, + .a = VK_CHANNEL_SWIZZLE_A, + }, + .subresourceRange = { + .aspectMask = aspect_mask, + .baseMipLevel = info->mipLevel, + .mipLevels = 1, + .baseArrayLayer = info->baseArraySlice, + .arraySize = info->arraySize, + }, + }, + NULL); pView->handle = anv_image_view_to_handle(iview).handle; @@ -636,12 +670,5 @@ anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) VkImageView _iview = { .handle = _aview.handle }; ANV_FROM_HANDLE(anv_image_view, iview, _iview); - /* Depth and stencil render targets have no RENDER_SURFACE_STATE. Instead, - * they use 3DSTATE_DEPTH_BUFFER and 3DSTATE_STENCIL_BUFFER. - */ - if (!anv_format_is_depth_or_stencil(iview->format)) { - anv_state_pool_free(&device->surface_state_pool, iview->surface_state); - } - - anv_device_free(device, iview); + anv_image_view_destroy(device, iview); } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index d69863b8375..c7c50ef87a9 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -1029,14 +1029,25 @@ do_buffer_copy(struct anv_cmd_buffer *cmd_buffer, cmd_buffer); struct anv_image_view dest_iview; - anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, - &(VkAttachmentViewCreateInfo) { - .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, + anv_image_view_init(&dest_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = dest_image, + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = copy_format, - .mipLevel = 0, - .baseArraySlice = 0, - .arraySize = 1, + .channels = { + .r = VK_CHANNEL_SWIZZLE_R, + .g = VK_CHANNEL_SWIZZLE_G, + .b = VK_CHANNEL_SWIZZLE_B, + .a = VK_CHANNEL_SWIZZLE_A, + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .mipLevels = 1, + .baseArrayLayer = 0, + .arraySize = 1, + }, }, cmd_buffer); @@ -1194,14 +1205,25 @@ void anv_CmdCopyImage( anv_finishme("FINISHME: copy multiple depth layers"); struct anv_image_view dest_iview; - anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, - &(VkAttachmentViewCreateInfo) { - .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, + anv_image_view_init(&dest_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = destImage, + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = dest_image->format->vk_format, - .mipLevel = pRegions[r].destSubresource.mipLevel, - .baseArraySlice = dest_array_slice, - .arraySize = 1, + .channels = { + VK_CHANNEL_SWIZZLE_R, + VK_CHANNEL_SWIZZLE_G, + VK_CHANNEL_SWIZZLE_B, + VK_CHANNEL_SWIZZLE_A + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = pRegions[r].destSubresource.mipLevel, + .mipLevels = 1, + .baseArrayLayer = dest_array_slice, + .arraySize = 1 + }, }, cmd_buffer); @@ -1283,14 +1305,25 @@ void anv_CmdBlitImage( anv_finishme("FINISHME: copy multiple depth layers"); struct anv_image_view dest_iview; - anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, - &(VkAttachmentViewCreateInfo) { - .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, + anv_image_view_init(&dest_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = destImage, + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = dest_image->format->vk_format, - .mipLevel = pRegions[r].destSubresource.mipLevel, - .baseArraySlice = dest_array_slice, - .arraySize = 1, + .channels = { + VK_CHANNEL_SWIZZLE_R, + VK_CHANNEL_SWIZZLE_G, + VK_CHANNEL_SWIZZLE_B, + VK_CHANNEL_SWIZZLE_A + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = pRegions[r].destSubresource.mipLevel, + .mipLevels = 1, + .baseArrayLayer = dest_array_slice, + .arraySize = 1 + }, }, cmd_buffer); @@ -1413,14 +1446,25 @@ void anv_CmdCopyBufferToImage( anv_finishme("FINISHME: copy multiple depth layers"); struct anv_image_view dest_iview; - anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, - &(VkAttachmentViewCreateInfo) { - .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, + anv_image_view_init(&dest_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = anv_image_to_handle(dest_image), + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = proxy_format, - .mipLevel = pRegions[r].imageSubresource.mipLevel, - .baseArraySlice = dest_array_slice, - .arraySize = 1, + .channels = { + VK_CHANNEL_SWIZZLE_R, + VK_CHANNEL_SWIZZLE_G, + VK_CHANNEL_SWIZZLE_B, + VK_CHANNEL_SWIZZLE_A + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = pRegions[r].imageSubresource.mipLevel, + .mipLevels = 1, + .baseArrayLayer = dest_array_slice, + .arraySize = 1 + }, }, cmd_buffer); @@ -1497,14 +1541,25 @@ void anv_CmdCopyImageToBuffer( dest_format, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &pRegions[r]); struct anv_image_view dest_iview; - anv_color_attachment_view_init(&dest_iview, cmd_buffer->device, - &(VkAttachmentViewCreateInfo) { - .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, + anv_image_view_init(&dest_iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = destImage, + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = dest_format, - .mipLevel = 0, - .baseArraySlice = 0, - .arraySize = 1, + .channels = { + VK_CHANNEL_SWIZZLE_R, + VK_CHANNEL_SWIZZLE_G, + VK_CHANNEL_SWIZZLE_B, + VK_CHANNEL_SWIZZLE_A + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = 0, + .mipLevels = 1, + .baseArrayLayer = 0, + .arraySize = 1 + }, }, cmd_buffer); @@ -1562,14 +1617,25 @@ void anv_CmdClearColorImage( for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { for (uint32_t s = 0; s < pRanges[r].arraySize; s++) { struct anv_image_view iview; - anv_color_attachment_view_init(&iview, cmd_buffer->device, - &(VkAttachmentViewCreateInfo) { - .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, + anv_image_view_init(&iview, cmd_buffer->device, + &(VkImageViewCreateInfo) { + .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = _image, + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = image->format->vk_format, - .mipLevel = pRanges[r].baseMipLevel + l, - .baseArraySlice = pRanges[r].baseArrayLayer + s, - .arraySize = 1, + .channels = { + VK_CHANNEL_SWIZZLE_R, + VK_CHANNEL_SWIZZLE_G, + VK_CHANNEL_SWIZZLE_B, + VK_CHANNEL_SWIZZLE_A + }, + .subresourceRange = { + .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, + .baseMipLevel = pRanges[r].baseMipLevel + l, + .mipLevels = 1, + .baseArrayLayer = pRanges[r].baseArrayLayer + s, + .arraySize = 1 + }, }, cmd_buffer); diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 06ab1dc65a6..e9735706a67 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1202,7 +1202,7 @@ struct anv_image { VkExtent3D extent; uint32_t levels; uint32_t array_size; - VkImageUsageFlags usage; /**< VkImageCreateInfo::usage */ + VkImageUsageFlags usage; /**< Superset of VkImageCreateInfo::usage. */ VkDeviceSize size; uint32_t alignment; @@ -1211,8 +1211,10 @@ struct anv_image { struct anv_bo *bo; VkDeviceSize offset; - /** RENDER_SURFACE_STATE.SurfaceType */ - uint8_t surf_type; + uint8_t surface_type; /**< RENDER_SURFACE_STATE.SurfaceType */ + + bool needs_nonrt_surface_state:1; + bool needs_color_rt_surface_state:1; /** * Image subsurfaces @@ -1247,10 +1249,15 @@ struct anv_buffer_view { struct anv_image_view { const struct anv_image *image; /**< VkImageViewCreateInfo::image */ const struct anv_format *format; /**< VkImageViewCreateInfo::format */ - struct anv_state surface_state; /**< RENDER_SURFACE_STATE */ struct anv_bo *bo; uint32_t offset; /**< Offset into bo. */ VkExtent3D extent; /**< Extent of VkImageViewCreateInfo::baseMipLevel. */ + + /** RENDER_SURFACE_STATE when using image as a color render target. */ + struct anv_state color_rt_surface_state; + + /** RENDER_SURFACE_STATE when using image as a non render target. */ + struct anv_state nonrt_surface_state; }; struct anv_image_create_info { @@ -1268,9 +1275,6 @@ struct anv_surface * anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlags aspect_mask); -struct anv_surface * -anv_image_get_surface_for_color_attachment(struct anv_image *image); - void anv_image_view_init(struct anv_image_view *view, struct anv_device *device, const VkImageViewCreateInfo* pCreateInfo, @@ -1288,21 +1292,6 @@ gen8_image_view_init(struct anv_image_view *iview, const VkImageViewCreateInfo* pCreateInfo, struct anv_cmd_buffer *cmd_buffer); -void anv_color_attachment_view_init(struct anv_image_view *iview, - struct anv_device *device, - const VkAttachmentViewCreateInfo* pCreateInfo, - struct anv_cmd_buffer *cmd_buffer); - -void gen7_color_attachment_view_init(struct anv_image_view *iview, - struct anv_device *device, - const VkAttachmentViewCreateInfo* pCreateInfo, - struct anv_cmd_buffer *cmd_buffer); - -void gen8_color_attachment_view_init(struct anv_image_view *iview, - struct anv_device *device, - const VkAttachmentViewCreateInfo* pCreateInfo, - struct anv_cmd_buffer *cmd_buffer); - VkResult anv_buffer_view_create(struct anv_device *device, const VkBufferViewCreateInfo *pCreateInfo, struct anv_buffer_view **bview_out); diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 5829d03d3e3..2497e39490d 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -113,6 +113,18 @@ static const uint32_t vk_to_gen_compare_op[] = { [VK_COMPARE_OP_ALWAYS] = PREFILTEROPALWAYS, }; +static struct anv_state +gen7_alloc_surface_state(struct anv_device *device, + struct anv_cmd_buffer *cmd_buffer) +{ + if (cmd_buffer) { + return anv_state_stream_alloc(&cmd_buffer->surface_state_stream, + 64, 64); + } else { + return anv_state_pool_alloc(&device->surface_state_pool, 64, 64); + } +} + VkResult gen7_CreateSampler( VkDevice _device, const VkSamplerCreateInfo* pCreateInfo, @@ -272,18 +284,17 @@ gen7_image_view_init(struct anv_image_view *iview, ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; + struct anv_surface *surface = anv_image_get_surface_for_aspect_mask(image, range->aspectMask); const struct anv_format *format = anv_format_for_vk_format(pCreateInfo->format); - const struct anv_image_view_info view_type_info = - anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType); - if (pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D) anv_finishme("non-2D image views"); + iview->image = image; iview->bo = image->bo; iview->offset = image->offset + surface->offset; iview->format = anv_format_for_vk_format(pCreateInfo->format); @@ -302,7 +313,7 @@ gen7_image_view_init(struct anv_image_view *iview, } struct GEN7_RENDER_SURFACE_STATE surface_state = { - .SurfaceType = view_type_info.surface_type, + .SurfaceType = image->surface_type, .SurfaceArray = image->array_size > 1, .SurfaceFormat = format->surface_format, .SurfaceVerticalAlignment = anv_valign[surface->v_align], @@ -316,7 +327,8 @@ gen7_image_view_init(struct anv_image_view *iview, .VerticalLineStride = 0, .VerticalLineStrideOffset = 0, - .RenderCacheReadWriteMode = false, + + .RenderCacheReadWriteMode = 0, /* TEMPLATE */ .Height = image->extent.height - 1, .Width = image->extent.width - 1, @@ -329,14 +341,8 @@ gen7_image_view_init(struct anv_image_view *iview, .SurfaceObjectControlState = GEN7_MOCS, - /* For render target surfaces, the hardware interprets field MIPCount/LOD as - * LOD. The Broadwell PRM says: - * - * MIPCountLOD defines the LOD that will be rendered into. - * SurfaceMinLOD is ignored. - */ - .MIPCountLOD = range->mipLevels - 1, - .SurfaceMinLOD = range->baseMipLevel, + .MIPCountLOD = 0, /* TEMPLATE */ + .SurfaceMinLOD = 0, /* TEMPLATE */ .MCSEnable = false, .RedClearColor = 0, @@ -347,85 +353,28 @@ gen7_image_view_init(struct anv_image_view *iview, .SurfaceBaseAddress = { NULL, iview->offset }, }; - if (cmd_buffer) { - iview->surface_state = - anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); - } else { - iview->surface_state = - anv_state_pool_alloc(&device->surface_state_pool, 64, 64); - } + if (image->needs_nonrt_surface_state) { + iview->nonrt_surface_state = + gen7_alloc_surface_state(device, cmd_buffer); - GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, - &surface_state); -} + surface_state.RenderCacheReadWriteMode = false; -void -gen7_color_attachment_view_init(struct anv_image_view *iview, - struct anv_device *device, - const VkAttachmentViewCreateInfo* pCreateInfo, - struct anv_cmd_buffer *cmd_buffer) -{ - ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_surface *surface = - anv_image_get_surface_for_color_attachment(image); - - assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); - anv_assert(pCreateInfo->arraySize > 0); - anv_assert(pCreateInfo->mipLevel < image->levels); - anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); - - iview->bo = image->bo; - iview->offset = image->offset + surface->offset; - iview->format = anv_format_for_vk_format(pCreateInfo->format); - - iview->extent = (VkExtent3D) { - .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), - .height = anv_minify(image->extent.height, pCreateInfo->mipLevel), - .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel), - }; - - uint32_t depth = 1; - if (pCreateInfo->arraySize > 1) { - depth = pCreateInfo->arraySize; - } else if (image->extent.depth > 1) { - depth = image->extent.depth; - } - - if (cmd_buffer) { - iview->surface_state = - anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); - } else { - iview->surface_state = - anv_state_pool_alloc(&device->surface_state_pool, 64, 64); - } - - struct GEN7_RENDER_SURFACE_STATE surface_state = { - .SurfaceType = SURFTYPE_2D, - .SurfaceArray = image->array_size > 1, - .SurfaceFormat = iview->format->surface_format, - .SurfaceVerticalAlignment = anv_valign[surface->v_align], - .SurfaceHorizontalAlignment = anv_halign[surface->h_align], - - /* From bspec (DevSNB, DevIVB): "Set Tile Walk to TILEWALK_XMAJOR if - * Tiled Surface is False." + /* For non render target surfaces, the hardware interprets field + * MIPCount/LOD as MIPCount. The range of levels accessible by the + * sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD]. */ - .TiledSurface = surface->tile_mode > LINEAR, - .TileWalk = surface->tile_mode == YMAJOR ? TILEWALK_YMAJOR : TILEWALK_XMAJOR, + surface_state.SurfaceMinLOD = range->baseMipLevel; + surface_state.MIPCountLOD = range->mipLevels - 1; - .VerticalLineStride = 0, - .VerticalLineStrideOffset = 0, - .RenderCacheReadWriteMode = WriteOnlyCache, + GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->nonrt_surface_state.map, + &surface_state); + } - .Height = image->extent.height - 1, - .Width = image->extent.width - 1, - .Depth = depth - 1, - .SurfacePitch = surface->stride - 1, - .MinimumArrayElement = pCreateInfo->baseArraySlice, - .NumberofMultisamples = MULTISAMPLECOUNT_1, - .XOffset = 0, - .YOffset = 0, + if (image->needs_color_rt_surface_state) { + iview->color_rt_surface_state = + gen7_alloc_surface_state(device, cmd_buffer); - .SurfaceObjectControlState = GEN7_MOCS, + surface_state.RenderCacheReadWriteMode = WriteOnlyCache; /* For render target surfaces, the hardware interprets field MIPCount/LOD as * LOD. The Broadwell PRM says: @@ -433,19 +382,10 @@ gen7_color_attachment_view_init(struct anv_image_view *iview, * MIPCountLOD defines the LOD that will be rendered into. * SurfaceMinLOD is ignored. */ - .SurfaceMinLOD = 0, - .MIPCountLOD = pCreateInfo->mipLevel, + surface_state.MIPCountLOD = range->baseMipLevel; + surface_state.SurfaceMinLOD = 0; - .MCSEnable = false, - .RedClearColor = 0, - .GreenClearColor = 0, - .BlueClearColor = 0, - .AlphaClearColor = 0, - .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, iview->offset }, - - }; - - GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, - &surface_state); + GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->color_rt_surface_state.map, + &surface_state); + } } diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 3c479e1c23e..5095ce060bf 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -139,6 +139,18 @@ static const uint8_t anv_valign[] = { [16] = VALIGN16, }; +static struct anv_state +gen8_alloc_surface_state(struct anv_device *device, + struct anv_cmd_buffer *cmd_buffer) +{ + if (cmd_buffer) { + return anv_state_stream_alloc(&cmd_buffer->surface_state_stream, + 64, 64); + } else { + return anv_state_pool_alloc(&device->surface_state_pool, 64, 64); + } +} + void gen8_image_view_init(struct anv_image_view *iview, struct anv_device *device, @@ -148,6 +160,7 @@ gen8_image_view_init(struct anv_image_view *iview, ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; + struct anv_surface *surface = anv_image_get_surface_for_aspect_mask(image, range->aspectMask); @@ -157,9 +170,7 @@ gen8_image_view_init(struct anv_image_view *iview, const struct anv_format *format_info = anv_format_for_vk_format(pCreateInfo->format); - const struct anv_image_view_info view_type_info = - anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType); - + iview->image = image; iview->bo = image->bo; iview->offset = image->offset + surface->offset; iview->format = format_info; @@ -219,7 +230,7 @@ gen8_image_view_init(struct anv_image_view *iview, }; struct GEN8_RENDER_SURFACE_STATE surface_state = { - .SurfaceType = view_type_info.surface_type, + .SurfaceType = image->surface_type, .SurfaceArray = image->array_size > 1, .SurfaceFormat = format_info->surface_format, .SurfaceVerticalAlignment = anv_valign[surface->v_align], @@ -248,12 +259,8 @@ gen8_image_view_init(struct anv_image_view *iview, .XOffset = 0, .YOffset = 0, - /* For sampler surfaces, the hardware interprets field MIPCount/LOD as - * MIPCount. The range of levels accessible by the sampler engine is - * [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD]. - */ - .MIPCountLOD = range->mipLevels - 1, - .SurfaceMinLOD = range->baseMipLevel, + .MIPCountLOD = 0, /* TEMPLATE */ + .SurfaceMinLOD = 0, /* TEMPLATE */ .AuxiliarySurfaceMode = AUX_NONE, .RedClearColor = 0, @@ -268,149 +275,37 @@ gen8_image_view_init(struct anv_image_view *iview, .SurfaceBaseAddress = { NULL, iview->offset }, }; - if (cmd_buffer) { - iview->surface_state = - anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); - } else { - iview->surface_state = - anv_state_pool_alloc(&device->surface_state_pool, 64, 64); + if (image->needs_nonrt_surface_state) { + iview->nonrt_surface_state = + gen8_alloc_surface_state(device, cmd_buffer); + + /* For non render target surfaces, the hardware interprets field + * MIPCount/LOD as MIPCount. The range of levels accessible by the + * sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD]. + */ + surface_state.SurfaceMinLOD = range->baseMipLevel; + surface_state.MIPCountLOD = range->mipLevels - 1; + + GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->nonrt_surface_state.map, + &surface_state); } - GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, - &surface_state); -} + if (image->needs_color_rt_surface_state) { + iview->color_rt_surface_state = + gen8_alloc_surface_state(device, cmd_buffer); -void -gen8_color_attachment_view_init(struct anv_image_view *iview, - struct anv_device *device, - const VkAttachmentViewCreateInfo* pCreateInfo, - struct anv_cmd_buffer *cmd_buffer) -{ - ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); - struct anv_surface *surface = - anv_image_get_surface_for_color_attachment(image); - const struct anv_format *format_info = - anv_format_for_vk_format(pCreateInfo->format); - - uint32_t depth = 1; /* RENDER_SURFACE_STATE::Depth */ - uint32_t rt_view_extent = 1; /* RENDER_SURFACE_STATE::RenderTargetViewExtent */ - - assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); - anv_assert(pCreateInfo->arraySize > 0); - anv_assert(pCreateInfo->mipLevel < image->levels); - anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size); - - iview->bo = image->bo; - iview->offset = image->offset + surface->offset; - iview->format = anv_format_for_vk_format(pCreateInfo->format); - - iview->extent = (VkExtent3D) { - .width = anv_minify(image->extent.width, pCreateInfo->mipLevel), - .height = anv_minify(image->extent.height, pCreateInfo->mipLevel), - .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel), - }; - - switch (image->type) { - case VK_IMAGE_TYPE_1D: - case VK_IMAGE_TYPE_2D: - /* From the Broadwell PRM >> RENDER_SURFACE_STATE::Depth: - * - * For SURFTYPE_1D, 2D, and CUBE: The range of this field is reduced - * by one for each increase from zero of Minimum Array Element. For - * example, if Minimum Array Element is set to 1024 on a 2D surface, - * the range of this field is reduced to [0,1023]. - */ - depth = pCreateInfo->arraySize; - - /* From the Broadwell PRM >> RENDER_SURFACE_STATE::RenderTargetViewExtent: - * - * For Render Target and Typed Dataport 1D and 2D Surfaces: - * This field must be set to the same value as the Depth field. - */ - rt_view_extent = depth; - break; - case VK_IMAGE_TYPE_3D: - /* From the Broadwell PRM >> RENDER_SURFACE_STATE::Depth: - * - * If the volume texture is MIP-mapped, this field specifies the - * depth of the base MIP level. - */ - depth = image->extent.depth; - - /* From the Broadwell PRM >> RENDER_SURFACE_STATE::RenderTargetViewExtent: - * - * For Render Target and Typed Dataport 3D Surfaces: This field - * indicates the extent of the accessible 'R' coordinates minus 1 on - * the LOD currently being rendered to. - */ - rt_view_extent = iview->extent.depth; - break; - default: - unreachable(!"bad VkImageType"); - } - - if (cmd_buffer) { - iview->surface_state = - anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64); - } else { - iview->surface_state = - anv_state_pool_alloc(&device->surface_state_pool, 64, 64); - } - - struct GEN8_RENDER_SURFACE_STATE surface_state = { - .SurfaceType = image->type, - .SurfaceArray = image->array_size > 1, - .SurfaceFormat = format_info->surface_format, - .SurfaceVerticalAlignment = anv_valign[surface->v_align], - .SurfaceHorizontalAlignment = anv_halign[surface->h_align], - .TileMode = surface->tile_mode, - .VerticalLineStride = 0, - .VerticalLineStrideOffset = 0, - .SamplerL2BypassModeDisable = true, - .RenderCacheReadWriteMode = WriteOnlyCache, - .MemoryObjectControlState = GEN8_MOCS, - - /* The driver sets BaseMipLevel in SAMPLER_STATE, not here in - * RENDER_SURFACE_STATE. The Broadwell PRM says "it is illegal to have - * both Base Mip Level fields nonzero". - */ - .BaseMipLevel = 0.0, - - .SurfaceQPitch = surface->qpitch >> 2, - .Height = image->extent.height - 1, - .Width = image->extent.width - 1, - .Depth = depth - 1, - .SurfacePitch = surface->stride - 1, - .RenderTargetViewExtent = rt_view_extent - 1, - .MinimumArrayElement = pCreateInfo->baseArraySlice, - .NumberofMultisamples = MULTISAMPLECOUNT_1, - .XOffset = 0, - .YOffset = 0, - - /* For render target surfaces, the hardware interprets field MIPCount/LOD as - * LOD. The Broadwell PRM says: + /* For render target surfaces, the hardware interprets field + * MIPCount/LOD as LOD. The Broadwell PRM says: * * MIPCountLOD defines the LOD that will be rendered into. * SurfaceMinLOD is ignored. */ - .SurfaceMinLOD = 0, - .MIPCountLOD = pCreateInfo->mipLevel, + surface_state.MIPCountLOD = range->baseMipLevel; + surface_state.SurfaceMinLOD = 0; - .AuxiliarySurfaceMode = AUX_NONE, - .RedClearColor = 0, - .GreenClearColor = 0, - .BlueClearColor = 0, - .AlphaClearColor = 0, - .ShaderChannelSelectRed = SCS_RED, - .ShaderChannelSelectGreen = SCS_GREEN, - .ShaderChannelSelectBlue = SCS_BLUE, - .ShaderChannelSelectAlpha = SCS_ALPHA, - .ResourceMinLOD = 0.0, - .SurfaceBaseAddress = { NULL, iview->offset }, - }; - - GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map, - &surface_state); + GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->color_rt_surface_state.map, + &surface_state); + } } VkResult gen8_CreateSampler( From 85ff3cfde32fe1614d93071f6a866bf797b4d12f Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 07:28:46 -0700 Subject: [PATCH 52/76] vk: Drop -Wextra Eliminates lots of warnings due to anv_meta.c's inclusion of nir.h. I like the extra warnings, and they should probably get fixed. However, git-grep reveals that no other Mesa directory uses -Wextra. Building Vulkan produces a lot of compiler warnings from core Mesa headers that no other Mesa developer sees, and hence no other Mesa developer will fix. --- src/vulkan/Makefile.am | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vulkan/Makefile.am b/src/vulkan/Makefile.am index eebe54d9475..0d0abd27300 100644 --- a/src/vulkan/Makefile.am +++ b/src/vulkan/Makefile.am @@ -51,11 +51,11 @@ AM_CPPFLAGS = \ -I$(top_builddir)/src/vulkan libvulkan_la_CFLAGS = \ - -Wall -Wextra -Wno-unused-parameter -fvisibility=hidden -O0 -g \ + -Wall -Wno-unused-parameter -fvisibility=hidden -O0 -g \ -Wstrict-prototypes -Wmissing-prototypes -Wno-override-init libvulkan_la_CXXFLAGS = \ - -Wall -Wextra -Wno-unused-parameter -fvisibility=hidden -O0 -g + -Wall -Wno-unused-parameter -fvisibility=hidden -O0 -g VULKAN_SOURCES = \ anv_allocator.c \ From 03dd72279f871c242a47bc4d03aef128bd5ae792 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 09:03:47 -0700 Subject: [PATCH 53/76] vk/image: Fix retrieval of anv_surface for depthstencil aspect If anv_image_get_surface_for_aspect_mask() is given a combined depthstencil aspect mask, and the image has a stencil surface but no depth surface, then return the stencil surface. Hacks on hacks. --- src/vulkan/anv_image.c | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 3f4d9b15c92..5973be1391b 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -596,15 +596,21 @@ anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlag assert(image->format->has_stencil); return &image->stencil_surface; case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT: - /* FINISHME: The Vulkan spec (git a511ba2) requires support for combined - * depth stencil formats. Specifically, it states: - * - * At least one of ename:VK_FORMAT_D24_UNORM_S8_UINT or - * ename:VK_FORMAT_D32_SFLOAT_S8_UINT must be supported. - */ - anv_finishme("combined depthstencil aspect"); - assert(image->format->depth_format); - return &image->depth_surface; + if (image->format->depth_format && image->format->has_stencil) { + /* FINISHME: The Vulkan spec (git a511ba2) requires support for combined + * depth stencil formats. Specifically, it states: + * + * At least one of ename:VK_FORMAT_D24_UNORM_S8_UINT or + * ename:VK_FORMAT_D32_SFLOAT_S8_UINT must be supported. + */ + anv_finishme("combined depthstencil aspect"); + return &image->depth_surface; + } else if (image->format->depth_format) { + return &image->depth_surface; + } else if (image->format->has_stencil) { + return &image->stencil_surface; + } + /* fallthrough */ default: unreachable("image does not have aspect"); return NULL; From 6dea1a9ba1acd7a957feb9ad43504e7accc4f8f8 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 07:30:52 -0700 Subject: [PATCH 54/76] vk/0.170.2: Merge VkAttachmentView into VkImageView --- include/vulkan/vulkan.h | 39 +++++---------------------------------- src/vulkan/anv_device.c | 3 +-- src/vulkan/anv_image.c | 34 ++-------------------------------- src/vulkan/anv_meta.c | 21 ++++----------------- 4 files changed, 12 insertions(+), 85 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index ce1d2d88e9f..4fe9e67fabc 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -91,7 +91,6 @@ VK_DEFINE_NONDISP_HANDLE(VkEvent) VK_DEFINE_NONDISP_HANDLE(VkQueryPool) VK_DEFINE_NONDISP_HANDLE(VkBufferView) VK_DEFINE_NONDISP_HANDLE(VkImageView) -VK_DEFINE_NONDISP_HANDLE(VkAttachmentView) VK_DEFINE_NONDISP_HANDLE(VkShaderModule) VK_DEFINE_NONDISP_HANDLE(VkShader) VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) @@ -962,10 +961,10 @@ typedef enum { typedef VkFlags VkImageAspectFlags; typedef enum { - VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, - VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, -} VkAttachmentViewCreateFlagBits; -typedef VkFlags VkAttachmentViewCreateFlags; + VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, + VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, +} VkImageViewCreateFlagBits; +typedef VkFlags VkImageViewCreateFlags; typedef VkFlags VkShaderModuleCreateFlags; typedef VkFlags VkShaderCreateFlags; @@ -1508,17 +1507,6 @@ typedef struct { VkImageSubresourceRange subresourceRange; } VkImageViewCreateInfo; -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - VkFormat format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VkAttachmentViewCreateFlags flags; -} VkAttachmentViewCreateInfo; - typedef struct { VkStructureType sType; const void* pNext; @@ -1784,7 +1772,6 @@ typedef struct { VkBufferView bufferView; VkSampler sampler; VkImageView imageView; - VkAttachmentView attachmentView; VkImageLayout imageLayout; } VkDescriptorInfo; @@ -1845,17 +1832,12 @@ typedef struct { uint32_t stencilBackRef; } VkDynamicDepthStencilStateCreateInfo; -typedef struct { - VkAttachmentView view; - VkImageLayout layout; -} VkAttachmentBindInfo; - typedef struct { VkStructureType sType; const void* pNext; VkRenderPass renderPass; uint32_t attachmentCount; - const VkAttachmentBindInfo* pAttachments; + const VkImageView* pAttachments; uint32_t width; uint32_t height; uint32_t layers; @@ -2137,8 +2119,6 @@ typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); -typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView); -typedef void (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView); typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); @@ -2542,15 +2522,6 @@ void VKAPI vkDestroyImageView( VkDevice device, VkImageView imageView); -VkResult VKAPI vkCreateAttachmentView( - VkDevice device, - const VkAttachmentViewCreateInfo* pCreateInfo, - VkAttachmentView* pView); - -void VKAPI vkDestroyAttachmentView( - VkDevice device, - VkAttachmentView attachmentView); - VkResult VKAPI vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index e7f74266e68..b10cc4512b4 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1968,8 +1968,7 @@ VkResult anv_CreateFramebuffer( framebuffer->attachment_count = pCreateInfo->attachmentCount; for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { - VkAttachmentView _aview = pCreateInfo->pAttachments[i].view; - VkImageView _iview = { _aview.handle }; + VkImageView _iview = pCreateInfo->pAttachments[i]; framebuffer->attachments[i] = anv_image_view_from_handle(_iview); } diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 5973be1391b..8522d0e8318 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -617,23 +617,7 @@ anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlag } } -VkResult -anv_CreateAttachmentView(VkDevice _device, - const VkAttachmentViewCreateInfo *info, - VkAttachmentView *pView) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_image_view *iview; - - assert(info->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO); - - iview = anv_device_alloc(device, sizeof(*iview), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (iview == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - const struct anv_format *format = anv_format_for_vk_format(info->format); - +#if 0 VkImageAspectFlags aspect_mask = 0; if (format->depth_format) aspect_mask |= VK_IMAGE_ASPECT_DEPTH_BIT; @@ -663,18 +647,4 @@ anv_CreateAttachmentView(VkDevice _device, }, }, NULL); - - pView->handle = anv_image_view_to_handle(iview).handle; - - return VK_SUCCESS; -} - -void -anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _aview) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - VkImageView _iview = { .handle = _aview.handle }; - ANV_FROM_HANDLE(anv_image_view, iview, _iview); - - anv_image_view_destroy(device, iview); -} +#endif diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index c7c50ef87a9..a0b7070ebfe 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -738,10 +738,6 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, VkExtent3D dest_extent) { struct anv_device *device = cmd_buffer->device; - - VkImageView dest_iview_h = anv_image_view_to_handle(dest_iview); - VkAttachmentView dest_aview_h = { .handle = dest_iview_h.handle }; - VkDescriptorPool dummy_desc_pool = { .handle = 1 }; struct blit_vb_data { @@ -837,11 +833,8 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, &(VkFramebufferCreateInfo) { .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, .attachmentCount = 1, - .pAttachments = (VkAttachmentBindInfo[]) { - { - .view = dest_aview_h, - .layout = VK_IMAGE_LAYOUT_GENERAL - } + .pAttachments = (VkImageView[]) { + anv_image_view_to_handle(dest_iview), }, .width = dest_iview->extent.width, .height = dest_iview->extent.height, @@ -1639,19 +1632,13 @@ void anv_CmdClearColorImage( }, cmd_buffer); - VkImageView iview_h = anv_image_view_to_handle(&iview); - VkAttachmentView aview_h = { .handle = iview_h.handle }; - VkFramebuffer fb; anv_CreateFramebuffer(anv_device_to_handle(cmd_buffer->device), &(VkFramebufferCreateInfo) { .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, .attachmentCount = 1, - .pAttachments = (VkAttachmentBindInfo[]) { - { - .view = aview_h, - .layout = VK_IMAGE_LAYOUT_GENERAL - } + .pAttachments = (VkImageView[]) { + anv_image_view_to_handle(&iview), }, .width = iview.extent.width, .height = iview.extent.height, From b1c024a9321cba865d152eb5f64ac74cff47125e Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 09:09:37 -0700 Subject: [PATCH 55/76] vk/meta: Fix -Wstrict-prototypes In C, functions with no arguments require a void argument. build_nir_clear_fragment_shader() lacked that. Fixes: anv_meta.c:70:1: warning: function declaration isn't a prototype [-Wstrict-prototypes] --- src/vulkan/anv_meta.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index a0b7070ebfe..c0e4112f363 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -67,7 +67,7 @@ build_nir_vertex_shader(bool attr_flat) } static nir_shader * -build_nir_clear_fragment_shader() +build_nir_clear_fragment_shader(void) { nir_builder b; From 941a1059541197dfb356b45f1e003745533c4b0e Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Wed, 7 Oct 2015 09:27:31 -0700 Subject: [PATCH 56/76] anv/private: Add a typed_memcpy macro This is amazingly helpful when copying arrays of things around. --- src/vulkan/anv_private.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index e9735706a67..ac9422f6b90 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -115,6 +115,11 @@ anv_clear_mask(uint32_t *inout_mask, uint32_t clear_mask) (b) = __builtin_ffs(__dword) - 1, __dword; \ __dword &= ~(1 << (b))) +#define typed_memcpy(dest, src, count) ({ \ + static_assert(sizeof(*src) == sizeof(*dest), ""); \ + memcpy((dest), (src), (count) * sizeof(*(src))); \ +}) + /* Define no kernel as 1, since that's an illegal offset for a kernel */ #define NO_KERNEL 1 From 55fcca306b349a959feecae8f84a6b62f532114f Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Wed, 7 Oct 2015 09:31:53 -0700 Subject: [PATCH 57/76] anv: Add a dynamic state data structure and basic helpers --- src/vulkan/anv_cmd_buffer.c | 72 +++++++++++++++++++++++++++++++++++++ src/vulkan/anv_private.h | 56 +++++++++++++++++++++++++++-- 2 files changed, 125 insertions(+), 3 deletions(-) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 7587f2ed103..78b17ea15ee 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -38,6 +38,78 @@ * is concerned, most of anv_cmd_buffer is magic. */ +/* TODO: These are taken from GLES. We should check the Vulkan spec */ +const struct anv_dynamic_state default_dynamic_state = { + .viewport = { + .count = 0, + }, + .scissor = { + .count = 0, + }, + .line_width = 1.0f, + .depth_bias = { + .bias = 0.0f, + .clamp = 0.0f, + .slope_scaled = 0.0f, + }, + .blend_constants = { 0.0f, 0.0f, 0.0f, 0.0f }, + .depth_bounds = { + .min = 0.0f, + .max = 1.0f, + }, + .stencil_compare_mask = { + .front = ~0u, + .back = ~0u, + }, + .stencil_write_mask = { + .front = ~0u, + .back = ~0u, + }, + .stencil_reference = { + .front = 0u, + .back = 0u, + }, +}; + +void +anv_dynamic_state_copy(struct anv_dynamic_state *dest, + const struct anv_dynamic_state *src, + uint32_t copy_mask) +{ + if (copy_mask & (1 << VK_DYNAMIC_STATE_VIEWPORT)) { + dest->viewport.count = src->viewport.count; + typed_memcpy(dest->viewport.viewports, src->viewport.viewports, + src->viewport.count); + } + + if (copy_mask & (1 << VK_DYNAMIC_STATE_SCISSOR)) { + dest->scissor.count = src->scissor.count; + typed_memcpy(dest->scissor.scissors, src->scissor.scissors, + src->scissor.count); + } + + if (copy_mask & (1 << VK_DYNAMIC_STATE_LINE_WIDTH)) + dest->line_width = src->line_width; + + if (copy_mask & (1 << VK_DYNAMIC_STATE_DEPTH_BIAS)) + dest->depth_bias = src->depth_bias; + + if (copy_mask & (1 << VK_DYNAMIC_STATE_BLEND_CONSTANTS)) + typed_memcpy(dest->blend_constants, src->blend_constants, 4); + + if (copy_mask & (1 << VK_DYNAMIC_STATE_DEPTH_BOUNDS)) + dest->depth_bounds = src->depth_bounds; + + if (copy_mask & (1 << VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK)) + dest->stencil_compare_mask = src->stencil_compare_mask; + + if (copy_mask & (1 << VK_DYNAMIC_STATE_STENCIL_WRITE_MASK)) + dest->stencil_write_mask = src->stencil_write_mask; + + if (copy_mask & (1 << VK_DYNAMIC_STATE_STENCIL_REFERENCE)) + dest->stencil_reference = src->stencil_reference; +} + static void anv_cmd_state_init(struct anv_cmd_state *state) { diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index ac9422f6b90..047c1cf4355 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -763,9 +763,11 @@ void anv_descriptor_set_destroy(struct anv_device *device, struct anv_descriptor_set *set); -#define MAX_VBS 32 -#define MAX_SETS 8 -#define MAX_RTS 8 +#define MAX_VBS 32 +#define MAX_SETS 8 +#define MAX_RTS 8 +#define MAX_VIEWPORTS 16 +#define MAX_SCISSORS 16 #define MAX_PUSH_CONSTANTS_SIZE 128 #define MAX_DYNAMIC_BUFFERS 16 #define MAX_IMAGES 8 @@ -839,6 +841,54 @@ struct anv_push_constants { struct brw_image_param images[MAX_IMAGES]; }; +struct anv_dynamic_state { + struct { + uint32_t count; + VkViewport viewports[MAX_VIEWPORTS]; + } viewport; + + struct { + uint32_t count; + VkRect2D scissors[MAX_SCISSORS]; + } scissor; + + float line_width; + + struct { + float bias; + float clamp; + float slope_scaled; + } depth_bias; + + float blend_constants[4]; + + struct { + float min; + float max; + } depth_bounds; + + struct { + uint32_t front; + uint32_t back; + } stencil_compare_mask; + + struct { + uint32_t front; + uint32_t back; + } stencil_write_mask; + + struct { + uint32_t front; + uint32_t back; + } stencil_reference; +}; + +extern const struct anv_dynamic_state default_dynamic_state; + +void anv_dynamic_state_copy(struct anv_dynamic_state *dest, + const struct anv_dynamic_state *src, + uint32_t copy_mask); + /** State required while building cmd buffer */ struct anv_cmd_state { uint32_t current_pipeline; From daf68a9465050c798012125e7150017c09576e0f Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 6 Oct 2015 17:21:44 -0700 Subject: [PATCH 58/76] vk/0.170.2: Switch to the new dynamic state model --- include/vulkan/vulkan.h | 185 ++++++++++++------------ src/vulkan/anv_cmd_buffer.c | 272 +++++++++++++++++++++++++++++++---- src/vulkan/anv_device.c | 29 +--- src/vulkan/anv_meta.c | 102 ++++--------- src/vulkan/anv_private.h | 73 +++------- src/vulkan/gen7_cmd_buffer.c | 125 +++++++++------- src/vulkan/gen7_state.c | 72 ---------- src/vulkan/gen8_cmd_buffer.c | 116 ++++++++++----- src/vulkan/gen8_state.c | 83 ----------- 9 files changed, 536 insertions(+), 521 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 4fe9e67fabc..abf87d81e83 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -101,10 +101,6 @@ VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) VK_DEFINE_NONDISP_HANDLE(VkSampler) VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) -VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) VK_DEFINE_NONDISP_HANDLE(VkCmdPool) @@ -683,6 +679,22 @@ typedef enum { VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF } VkBlendOp; +typedef enum { + 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_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + typedef enum { VK_TEX_FILTER_NEAREST = 0, VK_TEX_FILTER_LINEAR = 1, @@ -1068,6 +1080,13 @@ typedef enum { } VkCmdBufferResetFlagBits; typedef VkFlags VkCmdBufferResetFlags; +typedef enum { + VK_STENCIL_FACE_NONE = 0, + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + typedef enum { VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, } VkQueryControlFlagBits; @@ -1616,6 +1635,9 @@ typedef struct { VkStructureType sType; const void* pNext; uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; } VkPipelineViewportStateCreateInfo; typedef struct { @@ -1626,6 +1648,11 @@ typedef struct { VkFillMode fillMode; VkCullMode cullMode; VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBias; + float depthBiasClamp; + float slopeScaledDepthBias; + float lineWidth; } VkPipelineRasterStateCreateInfo; typedef struct { @@ -1642,6 +1669,9 @@ typedef struct { VkStencilOp stencilPassOp; VkStencilOp stencilDepthFailOp; VkCompareOp stencilCompareOp; + uint32_t stencilCompareMask; + uint32_t stencilWriteMask; + uint32_t stencilReference; } VkStencilOpState; typedef struct { @@ -1654,6 +1684,8 @@ typedef struct { VkBool32 stencilTestEnable; VkStencilOpState front; VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; } VkPipelineDepthStencilStateCreateInfo; typedef struct { @@ -1671,12 +1703,21 @@ typedef struct { VkStructureType sType; const void* pNext; VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; VkBool32 logicOpEnable; VkLogicOp logicOp; uint32_t attachmentCount; const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConst[4]; } VkPipelineColorBlendStateCreateInfo; +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + typedef struct { VkStructureType sType; const void* pNext; @@ -1690,6 +1731,7 @@ typedef struct { const VkPipelineMultisampleStateCreateInfo* pMultisampleState; const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; VkPipelineCreateFlags flags; VkPipelineLayout layout; VkRenderPass renderPass; @@ -1798,40 +1840,6 @@ typedef struct { uint32_t count; } VkCopyDescriptorSet; -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportAndScissorCount; - const VkViewport* pViewports; - const VkRect2D* pScissors; -} VkDynamicViewportStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float lineWidth; -} VkDynamicRasterStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float blendConst[4]; -} VkDynamicColorBlendStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float minDepthBounds; - float maxDepthBounds; - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VkDynamicDepthStencilStateCreateInfo; - typedef struct { VkStructureType sType; const void* pNext; @@ -2143,14 +2151,6 @@ typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescripto typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); @@ -2165,10 +2165,15 @@ typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); -typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState); -typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState); -typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth); +typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias); +typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]); +typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); +typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); +typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); @@ -2645,42 +2650,6 @@ VkResult VKAPI vkUpdateDescriptorSets( uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -VkResult VKAPI vkCreateDynamicViewportState( - VkDevice device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState); - -void VKAPI vkDestroyDynamicViewportState( - VkDevice device, - VkDynamicViewportState dynamicViewportState); - -VkResult VKAPI vkCreateDynamicRasterState( - VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState); - -void VKAPI vkDestroyDynamicRasterState( - VkDevice device, - VkDynamicRasterState dynamicRasterState); - -VkResult VKAPI vkCreateDynamicColorBlendState( - VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState); - -void VKAPI vkDestroyDynamicColorBlendState( - VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState); - -VkResult VKAPI vkCreateDynamicDepthStencilState( - VkDevice device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState); - -void VKAPI vkDestroyDynamicDepthStencilState( - VkDevice device, - VkDynamicDepthStencilState dynamicDepthStencilState); - VkResult VKAPI vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, @@ -2743,21 +2712,49 @@ void VKAPI vkCmdBindPipeline( VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -void VKAPI vkCmdBindDynamicViewportState( +void VKAPI vkCmdSetViewport( VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState); + uint32_t viewportCount, + const VkViewport* pViewports); -void VKAPI vkCmdBindDynamicRasterState( +void VKAPI vkCmdSetScissor( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState); + uint32_t scissorCount, + const VkRect2D* pScissors); -void VKAPI vkCmdBindDynamicColorBlendState( +void VKAPI vkCmdSetLineWidth( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState); + float lineWidth); -void VKAPI vkCmdBindDynamicDepthStencilState( +void VKAPI vkCmdSetDepthBias( VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState); + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias); + +void VKAPI vkCmdSetBlendConstants( + VkCmdBuffer cmdBuffer, + const float blendConst[4]); + +void VKAPI vkCmdSetDepthBounds( + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds); + +void VKAPI vkCmdSetStencilCompareMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask); + +void VKAPI vkCmdSetStencilWriteMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask); + +void VKAPI vkCmdSetStencilReference( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilReference); void VKAPI vkCmdBindDescriptorSets( VkCmdBuffer cmdBuffer, diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 78b17ea15ee..8486bd05a2c 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -113,22 +113,16 @@ anv_dynamic_state_copy(struct anv_dynamic_state *dest, static void anv_cmd_state_init(struct anv_cmd_state *state) { - state->rs_state = NULL; - state->vp_state = NULL; - state->cb_state = NULL; - state->ds_state = NULL; memset(&state->state_vf, 0, sizeof(state->state_vf)); memset(&state->descriptors, 0, sizeof(state->descriptors)); memset(&state->push_constants, 0, sizeof(state->push_constants)); - state->dirty = 0; + state->dirty = ~0; state->vb_dirty = 0; state->descriptors_dirty = 0; state->push_constants_dirty = 0; state->pipeline = NULL; - state->vp_state = NULL; - state->rs_state = NULL; - state->ds_state = NULL; + state->dynamic = default_dynamic_state; state->gen7.index_buffer = NULL; } @@ -333,48 +327,128 @@ void anv_CmdBindPipeline( } } -void anv_CmdBindDynamicViewportState( +void anv_CmdSetViewport( VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState) + uint32_t viewportCount, + const VkViewport* pViewports) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_vp_state, vp_state, dynamicViewportState); - cmd_buffer->state.vp_state = vp_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_VP_DIRTY; + cmd_buffer->state.dynamic.viewport.count = viewportCount; + memcpy(cmd_buffer->state.dynamic.viewport.viewports, + pViewports, viewportCount * sizeof(*pViewports)); + + cmd_buffer->state.dirty |= ANV_DYNAMIC_VIEWPORT_DIRTY; } -void anv_CmdBindDynamicRasterState( +void anv_CmdSetScissor( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) + uint32_t scissorCount, + const VkRect2D* pScissors) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_rs_state, rs_state, dynamicRasterState); - cmd_buffer->state.rs_state = rs_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_RS_DIRTY; + cmd_buffer->state.dynamic.scissor.count = scissorCount; + memcpy(cmd_buffer->state.dynamic.scissor.scissors, + pScissors, scissorCount * sizeof(*pScissors)); + + cmd_buffer->state.dirty |= ANV_DYNAMIC_SCISSOR_DIRTY; } -void anv_CmdBindDynamicColorBlendState( +void anv_CmdSetLineWidth( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) + float lineWidth) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_cb_state, cb_state, dynamicColorBlendState); - cmd_buffer->state.cb_state = cb_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_CB_DIRTY; + cmd_buffer->state.dynamic.line_width = lineWidth; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_LINE_WIDTH_DIRTY; } -void anv_CmdBindDynamicDepthStencilState( +void anv_CmdSetDepthBias( VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState) + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_ds_state, ds_state, dynamicDepthStencilState); - cmd_buffer->state.ds_state = ds_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_DS_DIRTY; + cmd_buffer->state.dynamic.depth_bias.bias = depthBias; + cmd_buffer->state.dynamic.depth_bias.clamp = depthBiasClamp; + cmd_buffer->state.dynamic.depth_bias.slope_scaled = slopeScaledDepthBias; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_DEPTH_BIAS_DIRTY; +} + +void anv_CmdSetBlendConstants( + VkCmdBuffer cmdBuffer, + const float blendConst[4]) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + memcpy(cmd_buffer->state.dynamic.blend_constants, + blendConst, sizeof(float) * 4); + + cmd_buffer->state.dirty |= ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY; +} + +void anv_CmdSetDepthBounds( + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + cmd_buffer->state.dynamic.depth_bounds.min = minDepthBounds; + cmd_buffer->state.dynamic.depth_bounds.max = maxDepthBounds; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_DEPTH_BOUNDS_DIRTY; +} + +void anv_CmdSetStencilCompareMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + if (faceMask & VK_STENCIL_FACE_FRONT_BIT) + cmd_buffer->state.dynamic.stencil_compare_mask.front = stencilCompareMask; + if (faceMask & VK_STENCIL_FACE_BACK_BIT) + cmd_buffer->state.dynamic.stencil_compare_mask.back = stencilCompareMask; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY; +} + +void anv_CmdSetStencilWriteMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + if (faceMask & VK_STENCIL_FACE_FRONT_BIT) + cmd_buffer->state.dynamic.stencil_write_mask.front = stencilWriteMask; + if (faceMask & VK_STENCIL_FACE_BACK_BIT) + cmd_buffer->state.dynamic.stencil_write_mask.back = stencilWriteMask; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY; +} + +void anv_CmdSetStencilReference( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilReference) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + if (faceMask & VK_STENCIL_FACE_FRONT_BIT) + cmd_buffer->state.dynamic.stencil_reference.front = stencilReference; + if (faceMask & VK_STENCIL_FACE_BACK_BIT) + cmd_buffer->state.dynamic.stencil_reference.back = stencilReference; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY; } void anv_CmdBindDescriptorSets( @@ -736,6 +810,148 @@ anv_cmd_buffer_begin_subpass(struct anv_cmd_buffer *cmd_buffer, } } +static void +emit_viewport_state(struct anv_cmd_buffer *cmd_buffer, + uint32_t count, const VkViewport *viewports) +{ + struct anv_state sf_clip_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, count * 64, 64); + struct anv_state cc_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, count * 8, 32); + + for (uint32_t i = 0; i < count; i++) { + const VkViewport *vp = &viewports[i]; + + /* The gen7 state struct has just the matrix and guardband fields, the + * gen8 struct adds the min/max viewport fields. */ + struct GEN8_SF_CLIP_VIEWPORT sf_clip_viewport = { + .ViewportMatrixElementm00 = vp->width / 2, + .ViewportMatrixElementm11 = vp->height / 2, + .ViewportMatrixElementm22 = (vp->maxDepth - vp->minDepth) / 2, + .ViewportMatrixElementm30 = vp->originX + vp->width / 2, + .ViewportMatrixElementm31 = vp->originY + vp->height / 2, + .ViewportMatrixElementm32 = (vp->maxDepth + vp->minDepth) / 2, + .XMinClipGuardband = -1.0f, + .XMaxClipGuardband = 1.0f, + .YMinClipGuardband = -1.0f, + .YMaxClipGuardband = 1.0f, + .XMinViewPort = vp->originX, + .XMaxViewPort = vp->originX + vp->width - 1, + .YMinViewPort = vp->originY, + .YMaxViewPort = vp->originY + vp->height - 1, + }; + + struct GEN7_CC_VIEWPORT cc_viewport = { + .MinimumDepth = vp->minDepth, + .MaximumDepth = vp->maxDepth + }; + + GEN8_SF_CLIP_VIEWPORT_pack(NULL, sf_clip_state.map + i * 64, + &sf_clip_viewport); + GEN7_CC_VIEWPORT_pack(NULL, cc_state.map + i * 32, &cc_viewport); + } + + anv_batch_emit(&cmd_buffer->batch, + GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC, + .CCViewportPointer = cc_state.offset); + anv_batch_emit(&cmd_buffer->batch, + GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP, + .SFClipViewportPointer = sf_clip_state.offset); +} + +void +anv_cmd_buffer_emit_viewport(struct anv_cmd_buffer *cmd_buffer) +{ + if (cmd_buffer->state.dynamic.viewport.count > 0) { + emit_viewport_state(cmd_buffer, cmd_buffer->state.dynamic.viewport.count, + cmd_buffer->state.dynamic.viewport.viewports); + } else { + /* If viewport count is 0, this is taken to mean "use the default" */ + emit_viewport_state(cmd_buffer, 1, + &(VkViewport) { + .originX = 0.0f, + .originY = 0.0f, + .width = cmd_buffer->state.framebuffer->width, + .height = cmd_buffer->state.framebuffer->height, + .minDepth = 0.0f, + .maxDepth = 1.0f, + }); + } +} + +static inline int64_t +clamp_int64(int64_t x, int64_t min, int64_t max) +{ + if (x < min) + return min; + else if (x < max) + return x; + else + return max; +} + +static void +emit_scissor_state(struct anv_cmd_buffer *cmd_buffer, + uint32_t count, const VkRect2D *scissors) +{ + struct anv_state scissor_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, count * 32, 32); + + for (uint32_t i = 0; i < count; i++) { + const VkRect2D *s = &scissors[i]; + + /* Since xmax and ymax are inclusive, we have to have xmax < xmin or + * ymax < ymin for empty clips. In case clip x, y, width height are all + * 0, the clamps below produce 0 for xmin, ymin, xmax, ymax, which isn't + * what we want. Just special case empty clips and produce a canonical + * empty clip. */ + static const struct GEN7_SCISSOR_RECT empty_scissor = { + .ScissorRectangleYMin = 1, + .ScissorRectangleXMin = 1, + .ScissorRectangleYMax = 0, + .ScissorRectangleXMax = 0 + }; + + const int max = 0xffff; + struct GEN7_SCISSOR_RECT scissor = { + /* Do this math using int64_t so overflow gets clamped correctly. */ + .ScissorRectangleYMin = clamp_int64(s->offset.y, 0, max), + .ScissorRectangleXMin = clamp_int64(s->offset.x, 0, max), + .ScissorRectangleYMax = clamp_int64((uint64_t) s->offset.y + s->extent.height - 1, 0, max), + .ScissorRectangleXMax = clamp_int64((uint64_t) s->offset.x + s->extent.width - 1, 0, max) + }; + + if (s->extent.width <= 0 || s->extent.height <= 0) { + GEN7_SCISSOR_RECT_pack(NULL, scissor_state.map + i * 32, + &empty_scissor); + } else { + GEN7_SCISSOR_RECT_pack(NULL, scissor_state.map + i * 32, &scissor); + } + } + + anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SCISSOR_STATE_POINTERS, + .ScissorRectPointer = scissor_state.offset); +} + +void +anv_cmd_buffer_emit_scissor(struct anv_cmd_buffer *cmd_buffer) +{ + if (cmd_buffer->state.dynamic.scissor.count > 0) { + emit_scissor_state(cmd_buffer, cmd_buffer->state.dynamic.scissor.count, + cmd_buffer->state.dynamic.scissor.scissors); + } else { + /* Emit a default scissor based on the currently bound framebuffer */ + emit_scissor_state(cmd_buffer, 1, + &(VkRect2D) { + .offset = { .x = 0, .y = 0, }, + .extent = { + .width = cmd_buffer->state.framebuffer->width, + .height = cmd_buffer->state.framebuffer->height, + }, + }); + } +} + void anv_CmdSetEvent( VkCmdBuffer cmdBuffer, VkEvent event, diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index b10cc4512b4..aec900065e6 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -389,7 +389,7 @@ VkResult anv_GetPhysicalDeviceLimits( .primitiveRestartForPatches = UINT32_MAX, .maxSamplerLodBias = 16, .maxSamplerAnisotropy = 16, - .maxViewports = 16, + .maxViewports = MAX_VIEWPORTS, .maxDynamicViewportStates = UINT32_MAX, .maxViewportDimensions = { (1 << 14), (1 << 14) }, .viewportBoundsRange = { -1.0, 1.0 }, /* FIXME */ @@ -1778,6 +1778,8 @@ VkResult anv_UpdateDescriptorSets( // State object functions +#if 0 + static inline int64_t clamp_int64(int64_t x, int64_t min, int64_t max) { @@ -1949,6 +1951,8 @@ void anv_DestroyDynamicDepthStencilState( anv_device_free(device, ds_state); } +#endif + VkResult anv_CreateFramebuffer( VkDevice _device, const VkFramebufferCreateInfo* pCreateInfo, @@ -1976,27 +1980,6 @@ VkResult anv_CreateFramebuffer( framebuffer->height = pCreateInfo->height; framebuffer->layers = pCreateInfo->layers; - anv_CreateDynamicViewportState(anv_device_to_handle(device), - &(VkDynamicViewportStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, - .viewportAndScissorCount = 1, - .pViewports = (VkViewport[]) { - { - .originX = 0, - .originY = 0, - .width = pCreateInfo->width, - .height = pCreateInfo->height, - .minDepth = 0, - .maxDepth = 1 - }, - }, - .pScissors = (VkRect2D[]) { - { { 0, 0 }, - { pCreateInfo->width, pCreateInfo->height } }, - } - }, - &framebuffer->vp_state); - *pFramebuffer = anv_framebuffer_to_handle(framebuffer); return VK_SUCCESS; @@ -2009,8 +1992,6 @@ void anv_DestroyFramebuffer( ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_framebuffer, fb, _fb); - anv_DestroyDynamicViewportState(anv_device_to_handle(device), - fb->vp_state); anv_device_free(device, fb); } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index c0e4112f363..565575ab219 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -293,20 +293,22 @@ struct anv_saved_state { struct anv_vertex_binding old_vertex_bindings[NUM_VB_USED]; struct anv_descriptor_set *old_descriptor_set0; struct anv_pipeline *old_pipeline; - struct anv_dynamic_ds_state *old_ds_state; - struct anv_dynamic_cb_state *old_cb_state; + uint32_t dynamic_flags; + struct anv_dynamic_state dynamic; }; static void anv_cmd_buffer_save(struct anv_cmd_buffer *cmd_buffer, - struct anv_saved_state *state) + struct anv_saved_state *state, + uint32_t dynamic_state) { state->old_pipeline = cmd_buffer->state.pipeline; state->old_descriptor_set0 = cmd_buffer->state.descriptors[0].set; memcpy(state->old_vertex_bindings, cmd_buffer->state.vertex_bindings, sizeof(state->old_vertex_bindings)); - state->old_ds_state = cmd_buffer->state.ds_state; - state->old_cb_state = cmd_buffer->state.cb_state; + state->dynamic_flags = dynamic_state; + anv_dynamic_state_copy(&state->dynamic, &cmd_buffer->state.dynamic, + dynamic_state); } static void @@ -322,15 +324,9 @@ anv_cmd_buffer_restore(struct anv_cmd_buffer *cmd_buffer, cmd_buffer->state.dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY; cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_VERTEX_BIT; - if (cmd_buffer->state.ds_state != state->old_ds_state) { - cmd_buffer->state.ds_state = state->old_ds_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_DS_DIRTY; - } - - if (cmd_buffer->state.cb_state != state->old_cb_state) { - cmd_buffer->state.cb_state = state->old_cb_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_CB_DIRTY; - } + anv_dynamic_state_copy(&cmd_buffer->state.dynamic, &state->dynamic, + state->dynamic_flags); + cmd_buffer->state.dirty |= state->dynamic_flags; } struct vue_header { @@ -396,23 +392,6 @@ meta_emit_clear(struct anv_cmd_buffer *cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, device->meta_state.clear.pipeline); - /* We don't need anything here, only set if not already set. */ - if (cmd_buffer->state.rs_state == NULL) - anv_CmdBindDynamicRasterState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.rs_state); - - if (cmd_buffer->state.vp_state == NULL) - anv_CmdBindDynamicViewportState(anv_cmd_buffer_to_handle(cmd_buffer), - cmd_buffer->state.framebuffer->vp_state); - - if (cmd_buffer->state.ds_state == NULL) - anv_CmdBindDynamicDepthStencilState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.ds_state); - - if (cmd_buffer->state.cb_state == NULL) - anv_CmdBindDynamicColorBlendState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.cb_state); - ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer), 3, num_instances, 0, 0); } @@ -466,7 +445,9 @@ anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer, } } - anv_cmd_buffer_save(cmd_buffer, &saved_state); + anv_cmd_buffer_save(cmd_buffer, &saved_state, + (1 << VK_DYNAMIC_STATE_VIEWPORT)); + cmd_buffer->state.dynamic.viewport.count = 0; struct anv_subpass subpass = { .input_count = 0, @@ -703,20 +684,8 @@ static void meta_prepare_blit(struct anv_cmd_buffer *cmd_buffer, struct anv_saved_state *saved_state) { - struct anv_device *device = cmd_buffer->device; - - anv_cmd_buffer_save(cmd_buffer, saved_state); - - /* We don't need anything here, only set if not already set. */ - if (cmd_buffer->state.rs_state == NULL) - anv_CmdBindDynamicRasterState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.rs_state); - if (cmd_buffer->state.ds_state == NULL) - anv_CmdBindDynamicDepthStencilState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.ds_state); - - anv_CmdBindDynamicColorBlendState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.cb_state); + anv_cmd_buffer_save(cmd_buffer, saved_state, + (1 << VK_DYNAMIC_STATE_VIEWPORT)); } struct blit_region { @@ -913,8 +882,15 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); } - anv_CmdBindDynamicViewportState(anv_cmd_buffer_to_handle(cmd_buffer), - anv_framebuffer_from_handle(fb)->vp_state); + anv_CmdSetViewport(anv_cmd_buffer_to_handle(cmd_buffer), 1, + &(VkViewport) { + .originX = 0.0f, + .originY = 0.0f, + .width = dest_iview->extent.width, + .height = dest_iview->extent.height, + .minDepth = 0.0f, + .maxDepth = 1.0f, + }); anv_CmdBindDescriptorSets(anv_cmd_buffer_to_handle(cmd_buffer), VK_PIPELINE_BIND_POINT_GRAPHICS, @@ -1604,7 +1580,9 @@ void anv_CmdClearColorImage( ANV_FROM_HANDLE(anv_image, image, _image); struct anv_saved_state saved_state; - anv_cmd_buffer_save(cmd_buffer, &saved_state); + anv_cmd_buffer_save(cmd_buffer, &saved_state, + (1 << VK_DYNAMIC_STATE_VIEWPORT)); + cmd_buffer->state.dynamic.viewport.count = 0; for (uint32_t r = 0; r < rangeCount; r++) { for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { @@ -1769,24 +1747,6 @@ anv_device_init_meta(struct anv_device *device) { anv_device_init_meta_clear_state(device); anv_device_init_meta_blit_state(device); - - ANV_CALL(CreateDynamicRasterState)(anv_device_to_handle(device), - &(VkDynamicRasterStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, - }, - &device->meta_state.shared.rs_state); - - ANV_CALL(CreateDynamicColorBlendState)(anv_device_to_handle(device), - &(VkDynamicColorBlendStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO - }, - &device->meta_state.shared.cb_state); - - ANV_CALL(CreateDynamicDepthStencilState)(anv_device_to_handle(device), - &(VkDynamicDepthStencilStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO - }, - &device->meta_state.shared.ds_state); } void @@ -1805,12 +1765,4 @@ anv_device_finish_meta(struct anv_device *device) device->meta_state.blit.pipeline_layout); anv_DestroyDescriptorSetLayout(anv_device_to_handle(device), device->meta_state.blit.ds_layout); - - /* Shared */ - anv_DestroyDynamicRasterState(anv_device_to_handle(device), - device->meta_state.shared.rs_state); - anv_DestroyDynamicColorBlendState(anv_device_to_handle(device), - device->meta_state.shared.cb_state); - anv_DestroyDynamicDepthStencilState(anv_device_to_handle(device), - device->meta_state.shared.ds_state); } diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 047c1cf4355..3d47739aae7 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -450,12 +450,6 @@ struct anv_meta_state { VkPipelineLayout pipeline_layout; VkDescriptorSetLayout ds_layout; } blit; - - struct { - VkDynamicRasterState rs_state; - VkDynamicColorBlendState cb_state; - VkDynamicDepthStencilState ds_state; - } shared; }; struct anv_queue { @@ -680,40 +674,6 @@ struct anv_device_memory { void * map; }; -struct anv_dynamic_vp_state { - struct anv_state sf_clip_vp; - struct anv_state cc_vp; - struct anv_state scissor; -}; - -struct anv_dynamic_rs_state { - struct { - uint32_t sf[GEN7_3DSTATE_SF_length]; - } gen7; - - struct { - uint32_t sf[GEN8_3DSTATE_SF_length]; - uint32_t raster[GEN8_3DSTATE_RASTER_length]; - } gen8; -}; - -struct anv_dynamic_ds_state { - struct { - uint32_t depth_stencil_state[GEN7_DEPTH_STENCIL_STATE_length]; - uint32_t color_calc_state[GEN8_COLOR_CALC_STATE_length]; - } gen7; - - struct { - uint32_t wm_depth_stencil[GEN8_3DSTATE_WM_DEPTH_STENCIL_length]; - uint32_t color_calc_state[GEN8_COLOR_CALC_STATE_length]; - } gen8; -}; - -struct anv_dynamic_cb_state { - uint32_t color_calc_state[GEN8_COLOR_CALC_STATE_length]; - -}; - struct anv_descriptor_slot { int8_t dynamic_slot; uint8_t index; @@ -800,12 +760,18 @@ struct anv_buffer { VkDeviceSize offset; }; -#define ANV_CMD_BUFFER_PIPELINE_DIRTY (1 << 0) -#define ANV_CMD_BUFFER_RS_DIRTY (1 << 2) -#define ANV_CMD_BUFFER_DS_DIRTY (1 << 3) -#define ANV_CMD_BUFFER_CB_DIRTY (1 << 4) -#define ANV_CMD_BUFFER_VP_DIRTY (1 << 5) -#define ANV_CMD_BUFFER_INDEX_BUFFER_DIRTY (1 << 6) +/* The first 9 correspond to 1 << VK_DYNAMIC_STATE_FOO */ +#define ANV_DYNAMIC_VIEWPORT_DIRTY (1 << 0) +#define ANV_DYNAMIC_SCISSOR_DIRTY (1 << 1) +#define ANV_DYNAMIC_LINE_WIDTH_DIRTY (1 << 2) +#define ANV_DYNAMIC_DEPTH_BIAS_DIRTY (1 << 3) +#define ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY (1 << 4) +#define ANV_DYNAMIC_DEPTH_BOUNDS_DIRTY (1 << 5) +#define ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY (1 << 6) +#define ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY (1 << 7) +#define ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY (1 << 8) +#define ANV_CMD_BUFFER_PIPELINE_DIRTY (1 << 9) +#define ANV_CMD_BUFFER_INDEX_BUFFER_DIRTY (1 << 10) struct anv_vertex_binding { struct anv_buffer * buffer; @@ -903,14 +869,11 @@ struct anv_cmd_state { struct anv_framebuffer * framebuffer; struct anv_render_pass * pass; struct anv_subpass * subpass; - struct anv_dynamic_rs_state * rs_state; - struct anv_dynamic_ds_state * ds_state; - struct anv_dynamic_vp_state * vp_state; - struct anv_dynamic_cb_state * cb_state; uint32_t state_vf[GEN8_3DSTATE_VF_length]; struct anv_vertex_binding vertex_bindings[MAX_VBS]; struct anv_descriptor_set_binding descriptors[MAX_SETS]; struct anv_push_constants * push_constants[VK_SHADER_STAGE_NUM]; + struct anv_dynamic_state dynamic; struct { struct anv_buffer * index_buffer; @@ -1028,6 +991,9 @@ anv_cmd_buffer_alloc_dynamic_state(struct anv_cmd_buffer *cmd_buffer, VkResult anv_cmd_buffer_new_binding_table_block(struct anv_cmd_buffer *cmd_buffer); +void anv_cmd_buffer_emit_viewport(struct anv_cmd_buffer *cmd_buffer); +void anv_cmd_buffer_emit_scissor(struct anv_cmd_buffer *cmd_buffer); + void gen7_cmd_buffer_emit_state_base_address(struct anv_cmd_buffer *cmd_buffer); void gen8_cmd_buffer_emit_state_base_address(struct anv_cmd_buffer *cmd_buffer); @@ -1369,9 +1335,6 @@ struct anv_framebuffer { uint32_t height; uint32_t layers; - /* Viewport for clears */ - VkDynamicViewportState vp_state; - uint32_t attachment_count; const struct anv_image_view * attachments[0]; }; @@ -1464,10 +1427,6 @@ ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_buffer_view, VkBufferView); ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_descriptor_set, VkDescriptorSet) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_descriptor_set_layout, VkDescriptorSetLayout) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_device_memory, VkDeviceMemory) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_cb_state, VkDynamicColorBlendState) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_ds_state, VkDynamicDepthStencilState) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_rs_state, VkDynamicRasterState) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_vp_state, VkDynamicViewportState) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_fence, VkFence) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_framebuffer, VkFramebuffer) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_image, VkImage) diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index 709e82e78a0..0106aa74aa6 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -256,60 +256,87 @@ gen7_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer) if (cmd_buffer->state.descriptors_dirty) anv_flush_descriptor_sets(cmd_buffer); - if (cmd_buffer->state.dirty & ANV_CMD_BUFFER_VP_DIRTY) { - struct anv_dynamic_vp_state *vp_state = cmd_buffer->state.vp_state; - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_SCISSOR_STATE_POINTERS, - .ScissorRectPointer = vp_state->scissor.offset); - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_VIEWPORT_STATE_POINTERS_CC, - .CCViewportPointer = vp_state->cc_vp.offset); - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP, - .SFClipViewportPointer = vp_state->sf_clip_vp.offset); + if (cmd_buffer->state.dirty & ANV_DYNAMIC_VIEWPORT_DIRTY) + anv_cmd_buffer_emit_viewport(cmd_buffer); + + if (cmd_buffer->state.dirty & ANV_DYNAMIC_SCISSOR_DIRTY) + anv_cmd_buffer_emit_scissor(cmd_buffer); + + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_LINE_WIDTH_DIRTY | + ANV_DYNAMIC_DEPTH_BIAS_DIRTY)) { + + bool enable_bias = cmd_buffer->state.dynamic.depth_bias.bias != 0.0f || + cmd_buffer->state.dynamic.depth_bias.slope_scaled != 0.0f; + + uint32_t sf_dw[GEN8_3DSTATE_SF_length]; + struct GEN7_3DSTATE_SF sf = { + GEN7_3DSTATE_SF_header, + .LineWidth = cmd_buffer->state.dynamic.line_width, + .GlobalDepthOffsetEnableSolid = enable_bias, + .GlobalDepthOffsetEnableWireframe = enable_bias, + .GlobalDepthOffsetEnablePoint = enable_bias, + .GlobalDepthOffsetConstant = cmd_buffer->state.dynamic.depth_bias.bias, + .GlobalDepthOffsetScale = cmd_buffer->state.dynamic.depth_bias.slope_scaled, + .GlobalDepthOffsetClamp = cmd_buffer->state.dynamic.depth_bias.clamp + }; + GEN7_3DSTATE_SF_pack(NULL, sf_dw, &sf); + + anv_batch_emit_merge(&cmd_buffer->batch, sf_dw, pipeline->gen7.sf); } - if (cmd_buffer->state.dirty & - (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_RS_DIRTY)) { - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.rs_state->gen7.sf, - pipeline->gen7.sf); - } - - if (cmd_buffer->state.dirty & - (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_DS_DIRTY)) { - struct anv_state state; - - if (cmd_buffer->state.ds_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - pipeline->gen7.depth_stencil_state, - GEN7_COLOR_CALC_STATE_length, 64); - else - state = anv_cmd_buffer_merge_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen7.depth_stencil_state, - pipeline->gen7.depth_stencil_state, - GEN7_DEPTH_STENCIL_STATE_length, 64); - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS, - .PointertoDEPTH_STENCIL_STATE = state.offset); - } - - if (cmd_buffer->state.dirty & - (ANV_CMD_BUFFER_CB_DIRTY | ANV_CMD_BUFFER_DS_DIRTY)) { - struct anv_state state; - if (cmd_buffer->state.ds_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.cb_state->color_calc_state, - GEN7_COLOR_CALC_STATE_length, 64); - else if (cmd_buffer->state.cb_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen7.color_calc_state, - GEN7_COLOR_CALC_STATE_length, 64); - else - state = anv_cmd_buffer_merge_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen7.color_calc_state, - cmd_buffer->state.cb_state->color_calc_state, - GEN7_COLOR_CALC_STATE_length, 64); + if (cmd_buffer->state.dirty & (ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY | + ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY)) { + struct anv_state cc_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, + GEN7_COLOR_CALC_STATE_length, 64); + struct GEN7_COLOR_CALC_STATE cc = { + .BlendConstantColorRed = cmd_buffer->state.dynamic.blend_constants[0], + .BlendConstantColorGreen = cmd_buffer->state.dynamic.blend_constants[1], + .BlendConstantColorBlue = cmd_buffer->state.dynamic.blend_constants[2], + .BlendConstantColorAlpha = cmd_buffer->state.dynamic.blend_constants[3], + .StencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.front, + .BackFaceStencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.back, + }; + GEN7_COLOR_CALC_STATE_pack(NULL, cc_state.map, &cc); anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_CC_STATE_POINTERS, - .ColorCalcStatePointer = state.offset); + .ColorCalcStatePointer = cc_state.offset); + } + + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY | + ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY)) { + uint32_t depth_stencil_dw[GEN7_DEPTH_STENCIL_STATE_length]; + + struct GEN7_DEPTH_STENCIL_STATE depth_stencil = { + /* Is this what we need to do? */ + .StencilBufferWriteEnable = + cmd_buffer->state.dynamic.stencil_write_mask.front != 0, + + .StencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.front & 0xff, + .StencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.front & 0xff, + + .BackfaceStencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.back & 0xff, + .BackfaceStencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.back & 0xff, + }; + GEN7_DEPTH_STENCIL_STATE_pack(NULL, depth_stencil_dw, &depth_stencil); + + struct anv_state ds_state = + anv_cmd_buffer_merge_dynamic(cmd_buffer, depth_stencil_dw, + pipeline->gen7.depth_stencil_state, + GEN7_DEPTH_STENCIL_STATE_length, 64); + + anv_batch_emit(&cmd_buffer->batch, + GEN7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS, + .PointertoDEPTH_STENCIL_STATE = ds_state.offset); } if (cmd_buffer->state.gen7.index_buffer && diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 2497e39490d..d317fa4ec16 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -192,78 +192,6 @@ VkResult gen7_CreateSampler( return VK_SUCCESS; } -VkResult gen7_CreateDynamicRasterState( - VkDevice _device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_rs_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - bool enable_bias = pCreateInfo->depthBias != 0.0f || - pCreateInfo->slopeScaledDepthBias != 0.0f; - - struct GEN7_3DSTATE_SF sf = { - GEN7_3DSTATE_SF_header, - .LineWidth = pCreateInfo->lineWidth, - .GlobalDepthOffsetEnableSolid = enable_bias, - .GlobalDepthOffsetEnableWireframe = enable_bias, - .GlobalDepthOffsetEnablePoint = enable_bias, - .GlobalDepthOffsetConstant = pCreateInfo->depthBias, - .GlobalDepthOffsetScale = pCreateInfo->slopeScaledDepthBias, - .GlobalDepthOffsetClamp = pCreateInfo->depthBiasClamp - }; - - GEN7_3DSTATE_SF_pack(NULL, state->gen7.sf, &sf); - - *pState = anv_dynamic_rs_state_to_handle(state); - - return VK_SUCCESS; -} - -VkResult gen7_CreateDynamicDepthStencilState( - VkDevice _device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_ds_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN7_DEPTH_STENCIL_STATE depth_stencil_state = { - .StencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .StencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - .BackfaceStencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .BackfaceStencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - }; - - GEN7_DEPTH_STENCIL_STATE_pack(NULL, state->gen7.depth_stencil_state, - &depth_stencil_state); - - struct GEN7_COLOR_CALC_STATE color_calc_state = { - .StencilReferenceValue = pCreateInfo->stencilFrontRef, - .BackFaceStencilReferenceValue = pCreateInfo->stencilBackRef - }; - - GEN7_COLOR_CALC_STATE_pack(NULL, state->gen7.color_calc_state, &color_calc_state); - - *pState = anv_dynamic_ds_state_to_handle(state); - - return VK_SUCCESS; -} static const uint8_t anv_halign[] = { [4] = HALIGN_4, diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index 1cd4a8561e6..a1db0170c09 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -121,57 +121,95 @@ gen8_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer) if (cmd_buffer->state.push_constants_dirty) gen8_cmd_buffer_flush_push_constants(cmd_buffer); - if (cmd_buffer->state.dirty & ANV_CMD_BUFFER_VP_DIRTY) { - struct anv_dynamic_vp_state *vp_state = cmd_buffer->state.vp_state; - anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SCISSOR_STATE_POINTERS, - .ScissorRectPointer = vp_state->scissor.offset); - anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC, - .CCViewportPointer = vp_state->cc_vp.offset); - anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP, - .SFClipViewportPointer = vp_state->sf_clip_vp.offset); + if (cmd_buffer->state.dirty & ANV_DYNAMIC_VIEWPORT_DIRTY) + anv_cmd_buffer_emit_viewport(cmd_buffer); + + if (cmd_buffer->state.dirty & ANV_DYNAMIC_SCISSOR_DIRTY) + anv_cmd_buffer_emit_scissor(cmd_buffer); + + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_LINE_WIDTH_DIRTY)) { + uint32_t sf_dw[GEN8_3DSTATE_SF_length]; + struct GEN8_3DSTATE_SF sf = { + GEN8_3DSTATE_SF_header, + .LineWidth = cmd_buffer->state.dynamic.line_width, + }; + GEN8_3DSTATE_SF_pack(NULL, sf_dw, &sf); + anv_batch_emit_merge(&cmd_buffer->batch, sf_dw, pipeline->gen8.sf); } if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | - ANV_CMD_BUFFER_RS_DIRTY)) { - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.rs_state->gen8.sf, - pipeline->gen8.sf); - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.rs_state->gen8.raster, + ANV_DYNAMIC_DEPTH_BIAS_DIRTY)) { + bool enable_bias = cmd_buffer->state.dynamic.depth_bias.bias != 0.0f || + cmd_buffer->state.dynamic.depth_bias.slope_scaled != 0.0f; + + uint32_t raster_dw[GEN8_3DSTATE_RASTER_length]; + struct GEN8_3DSTATE_RASTER raster = { + GEN8_3DSTATE_RASTER_header, + .GlobalDepthOffsetEnableSolid = enable_bias, + .GlobalDepthOffsetEnableWireframe = enable_bias, + .GlobalDepthOffsetEnablePoint = enable_bias, + .GlobalDepthOffsetConstant = cmd_buffer->state.dynamic.depth_bias.bias, + .GlobalDepthOffsetScale = cmd_buffer->state.dynamic.depth_bias.slope_scaled, + .GlobalDepthOffsetClamp = cmd_buffer->state.dynamic.depth_bias.clamp + }; + GEN8_3DSTATE_RASTER_pack(NULL, raster_dw, &raster); + anv_batch_emit_merge(&cmd_buffer->batch, raster_dw, pipeline->gen8.raster); } - if (cmd_buffer->state.ds_state && - (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | - ANV_CMD_BUFFER_DS_DIRTY))) { - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.ds_state->gen8.wm_depth_stencil, - pipeline->gen8.wm_depth_stencil); - } - - if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_CB_DIRTY | - ANV_CMD_BUFFER_DS_DIRTY)) { - struct anv_state state; - if (cmd_buffer->state.ds_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.cb_state->color_calc_state, - GEN8_COLOR_CALC_STATE_length, 64); - else if (cmd_buffer->state.cb_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen8.color_calc_state, - GEN8_COLOR_CALC_STATE_length, 64); - else - state = anv_cmd_buffer_merge_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen8.color_calc_state, - cmd_buffer->state.cb_state->color_calc_state, - GEN8_COLOR_CALC_STATE_length, 64); + if (cmd_buffer->state.dirty & (ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY | + ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY)) { + struct anv_state cc_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, + GEN8_COLOR_CALC_STATE_length, 64); + struct GEN8_COLOR_CALC_STATE cc = { + .BlendConstantColorRed = cmd_buffer->state.dynamic.blend_constants[0], + .BlendConstantColorGreen = cmd_buffer->state.dynamic.blend_constants[1], + .BlendConstantColorBlue = cmd_buffer->state.dynamic.blend_constants[2], + .BlendConstantColorAlpha = cmd_buffer->state.dynamic.blend_constants[3], + .StencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.front, + .BackFaceStencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.back, + }; + GEN8_COLOR_CALC_STATE_pack(NULL, cc_state.map, &cc); anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_CC_STATE_POINTERS, - .ColorCalcStatePointer = state.offset, + .ColorCalcStatePointer = cc_state.offset, .ColorCalcStatePointerValid = true); } + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY | + ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY)) { + uint32_t wm_depth_stencil_dw[GEN8_3DSTATE_WM_DEPTH_STENCIL_length]; + + struct GEN8_3DSTATE_WM_DEPTH_STENCIL wm_depth_stencil = { + GEN8_3DSTATE_WM_DEPTH_STENCIL_header, + + /* Is this what we need to do? */ + .StencilBufferWriteEnable = + cmd_buffer->state.dynamic.stencil_write_mask.front != 0, + + .StencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.front & 0xff, + .StencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.front & 0xff, + + .BackfaceStencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.back & 0xff, + .BackfaceStencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.back & 0xff, + }; + GEN8_3DSTATE_WM_DEPTH_STENCIL_pack(NULL, wm_depth_stencil_dw, + &wm_depth_stencil); + + anv_batch_emit_merge(&cmd_buffer->batch, wm_depth_stencil_dw, + pipeline->gen8.wm_depth_stencil); + } + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_INDEX_BUFFER_DIRTY)) { anv_batch_emit_merge(&cmd_buffer->batch, diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 5095ce060bf..9be3bf46021 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -29,46 +29,6 @@ #include "anv_private.h" -VkResult gen8_CreateDynamicRasterState( - VkDevice _device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_rs_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN8_3DSTATE_SF sf = { - GEN8_3DSTATE_SF_header, - .LineWidth = pCreateInfo->lineWidth, - }; - - GEN8_3DSTATE_SF_pack(NULL, state->gen8.sf, &sf); - - bool enable_bias = pCreateInfo->depthBias != 0.0f || - pCreateInfo->slopeScaledDepthBias != 0.0f; - struct GEN8_3DSTATE_RASTER raster = { - .GlobalDepthOffsetEnableSolid = enable_bias, - .GlobalDepthOffsetEnableWireframe = enable_bias, - .GlobalDepthOffsetEnablePoint = enable_bias, - .GlobalDepthOffsetConstant = pCreateInfo->depthBias, - .GlobalDepthOffsetScale = pCreateInfo->slopeScaledDepthBias, - .GlobalDepthOffsetClamp = pCreateInfo->depthBiasClamp - }; - - GEN8_3DSTATE_RASTER_pack(NULL, state->gen8.raster, &raster); - - *pState = anv_dynamic_rs_state_to_handle(state); - - return VK_SUCCESS; -} - void gen8_fill_buffer_surface_state(void *state, const struct anv_format *format, uint32_t offset, uint32_t range) @@ -407,46 +367,3 @@ VkResult gen8_CreateSampler( return VK_SUCCESS; } - -VkResult gen8_CreateDynamicDepthStencilState( - VkDevice _device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_ds_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN8_3DSTATE_WM_DEPTH_STENCIL wm_depth_stencil = { - GEN8_3DSTATE_WM_DEPTH_STENCIL_header, - - /* Is this what we need to do? */ - .StencilBufferWriteEnable = pCreateInfo->stencilWriteMask != 0, - - .StencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .StencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - - .BackfaceStencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .BackfaceStencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - }; - - GEN8_3DSTATE_WM_DEPTH_STENCIL_pack(NULL, state->gen8.wm_depth_stencil, - &wm_depth_stencil); - - struct GEN8_COLOR_CALC_STATE color_calc_state = { - .StencilReferenceValue = pCreateInfo->stencilFrontRef, - .BackFaceStencilReferenceValue = pCreateInfo->stencilBackRef - }; - - GEN8_COLOR_CALC_STATE_pack(NULL, state->gen8.color_calc_state, &color_calc_state); - - *pState = anv_dynamic_ds_state_to_handle(state); - - return VK_SUCCESS; -} From 1a52bc30390d56493ea2d0a950d8b9f01519ed24 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Wed, 7 Oct 2015 09:28:21 -0700 Subject: [PATCH 59/76] anv/pipeline: Add support for dynamic state in pipelines --- src/vulkan/anv_cmd_buffer.c | 6 +++ src/vulkan/anv_pipeline.c | 94 +++++++++++++++++++++++++++++++++++++ src/vulkan/anv_private.h | 3 ++ 3 files changed, 103 insertions(+) diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 8486bd05a2c..28d9dd9d694 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -319,6 +319,12 @@ void anv_CmdBindPipeline( cmd_buffer->state.vb_dirty |= pipeline->vb_used; cmd_buffer->state.dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY; cmd_buffer->state.push_constants_dirty |= pipeline->active_stages; + + /* Apply the dynamic state from the pipeline */ + cmd_buffer->state.dirty |= pipeline->dynamic_state_mask; + anv_dynamic_state_copy(&cmd_buffer->state.dynamic, + &pipeline->dynamic_state, + pipeline->dynamic_state_mask); break; default: diff --git a/src/vulkan/anv_pipeline.c b/src/vulkan/anv_pipeline.c index 192a4b17ae0..75f640154cc 100644 --- a/src/vulkan/anv_pipeline.c +++ b/src/vulkan/anv_pipeline.c @@ -177,6 +177,98 @@ static const uint32_t vk_to_gen_primitive_type[] = { [VK_PRIMITIVE_TOPOLOGY_PATCH] = _3DPRIM_PATCHLIST_1 }; +static void +anv_pipeline_init_dynamic_state(struct anv_pipeline *pipeline, + const VkGraphicsPipelineCreateInfo *pCreateInfo) +{ + pipeline->dynamic_state_mask = 0; + + if (pCreateInfo->pDynamicState == NULL) + return; + + uint32_t count = pCreateInfo->pDynamicState->dynamicStateCount; + struct anv_dynamic_state *dynamic = &pipeline->dynamic_state; + + for (uint32_t s = 0; s < count; s++) { + VkDynamicState state = pCreateInfo->pDynamicState->pDynamicStates[s]; + + assert(state < 32); + pipeline->dynamic_state_mask |= (1u << state); + + switch (state) { + case VK_DYNAMIC_STATE_VIEWPORT: + assert(pCreateInfo->pViewportState); + dynamic->viewport.count = pCreateInfo->pViewportState->viewportCount; + typed_memcpy(dynamic->viewport.viewports, + pCreateInfo->pViewportState->pViewports, + pCreateInfo->pViewportState->viewportCount); + break; + + case VK_DYNAMIC_STATE_SCISSOR: + assert(pCreateInfo->pViewportState); + dynamic->scissor.count = pCreateInfo->pViewportState->scissorCount; + typed_memcpy(dynamic->scissor.scissors, + pCreateInfo->pViewportState->pScissors, + pCreateInfo->pViewportState->scissorCount); + break; + + case VK_DYNAMIC_STATE_LINE_WIDTH: + assert(pCreateInfo->pRasterState); + dynamic->line_width = pCreateInfo->pRasterState->lineWidth; + break; + + case VK_DYNAMIC_STATE_DEPTH_BIAS: + assert(pCreateInfo->pRasterState); + dynamic->depth_bias.bias = pCreateInfo->pRasterState->depthBias; + dynamic->depth_bias.clamp = pCreateInfo->pRasterState->depthBiasClamp; + dynamic->depth_bias.slope_scaled = + pCreateInfo->pRasterState->slopeScaledDepthBias; + break; + + case VK_DYNAMIC_STATE_BLEND_CONSTANTS: + assert(pCreateInfo->pColorBlendState); + typed_memcpy(dynamic->blend_constants, + pCreateInfo->pColorBlendState->blendConst, 4); + break; + + case VK_DYNAMIC_STATE_DEPTH_BOUNDS: + assert(pCreateInfo->pDepthStencilState); + dynamic->depth_bounds.min = + pCreateInfo->pDepthStencilState->minDepthBounds; + dynamic->depth_bounds.max = + pCreateInfo->pDepthStencilState->maxDepthBounds; + break; + + case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: + assert(pCreateInfo->pDepthStencilState); + dynamic->stencil_compare_mask.front = + pCreateInfo->pDepthStencilState->front.stencilCompareMask; + dynamic->stencil_compare_mask.back = + pCreateInfo->pDepthStencilState->back.stencilCompareMask; + break; + + case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: + assert(pCreateInfo->pDepthStencilState); + dynamic->stencil_write_mask.front = + pCreateInfo->pDepthStencilState->front.stencilWriteMask; + dynamic->stencil_write_mask.back = + pCreateInfo->pDepthStencilState->back.stencilWriteMask; + break; + + case VK_DYNAMIC_STATE_STENCIL_REFERENCE: + assert(pCreateInfo->pDepthStencilState); + dynamic->stencil_reference.front = + pCreateInfo->pDepthStencilState->front.stencilReference; + dynamic->stencil_reference.back = + pCreateInfo->pDepthStencilState->back.stencilReference; + break; + + default: + assert(!"Invalid dynamic state"); + } + } +} + VkResult anv_pipeline_init(struct anv_pipeline *pipeline, struct anv_device *device, const VkGraphicsPipelineCreateInfo *pCreateInfo, @@ -205,6 +297,8 @@ anv_pipeline_init(struct anv_pipeline *pipeline, struct anv_device *device, anv_shader_from_handle(pCreateInfo->pStages[i].shader); } + anv_pipeline_init_dynamic_state(pipeline, pCreateInfo); + if (pCreateInfo->pTessellationState) anv_finishme("VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"); if (pCreateInfo->pViewportState) diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 3d47739aae7..0d1998d659c 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -1046,6 +1046,9 @@ struct anv_pipeline { struct anv_batch batch; uint32_t batch_data[256]; struct anv_reloc_list batch_relocs; + uint32_t dynamic_state_mask; + struct anv_dynamic_state dynamic_state; + struct anv_shader * shaders[VK_SHADER_STAGE_NUM]; struct anv_pipeline_layout * layout; bool use_repclear; From 010c6efd6510ebe319eceda73957b910024a210e Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Wed, 7 Oct 2015 09:44:51 -0700 Subject: [PATCH 60/76] vk/0.170.2: Make vkUpdateDescriptorSets return void --- include/vulkan/vulkan.h | 4 ++-- src/vulkan/anv_device.c | 4 +--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index abf87d81e83..f453553ae5c 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -2150,7 +2150,7 @@ typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorP typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); -typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); @@ -2643,7 +2643,7 @@ VkResult VKAPI vkFreeDescriptorSets( uint32_t count, const VkDescriptorSet* pDescriptorSets); -VkResult VKAPI vkUpdateDescriptorSets( +void VKAPI vkUpdateDescriptorSets( VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index aec900065e6..75c4c2c88d8 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1693,7 +1693,7 @@ VkResult anv_FreeDescriptorSets( return VK_SUCCESS; } -VkResult anv_UpdateDescriptorSets( +void anv_UpdateDescriptorSets( VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, @@ -1772,8 +1772,6 @@ VkResult anv_UpdateDescriptorSets( src->descriptors[copy->srcBinding + j]; } } - - return VK_SUCCESS; } // State object functions From 982466aeffc89b29b5a2ccabe61dfd9b9a9085aa Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Wed, 7 Oct 2015 09:45:47 -0700 Subject: [PATCH 61/76] anv/device: Remove some #ifdef'd out code This was a left-over from the dynamic state update. --- src/vulkan/anv_device.c | 177 ---------------------------------------- 1 file changed, 177 deletions(-) diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 75c4c2c88d8..be744bb9b55 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1774,183 +1774,6 @@ void anv_UpdateDescriptorSets( } } -// State object functions - -#if 0 - -static inline int64_t -clamp_int64(int64_t x, int64_t min, int64_t max) -{ - if (x < min) - return min; - else if (x < max) - return x; - else - return max; -} - -VkResult anv_CreateDynamicViewportState( - VkDevice _device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_vp_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - unsigned count = pCreateInfo->viewportAndScissorCount; - state->sf_clip_vp = anv_state_pool_alloc(&device->dynamic_state_pool, - count * 64, 64); - state->cc_vp = anv_state_pool_alloc(&device->dynamic_state_pool, - count * 8, 32); - state->scissor = anv_state_pool_alloc(&device->dynamic_state_pool, - count * 32, 32); - - for (uint32_t i = 0; i < pCreateInfo->viewportAndScissorCount; i++) { - const VkViewport *vp = &pCreateInfo->pViewports[i]; - const VkRect2D *s = &pCreateInfo->pScissors[i]; - - /* The gen7 state struct has just the matrix and guardband fields, the - * gen8 struct adds the min/max viewport fields. */ - struct GEN8_SF_CLIP_VIEWPORT sf_clip_viewport = { - .ViewportMatrixElementm00 = vp->width / 2, - .ViewportMatrixElementm11 = vp->height / 2, - .ViewportMatrixElementm22 = (vp->maxDepth - vp->minDepth) / 2, - .ViewportMatrixElementm30 = vp->originX + vp->width / 2, - .ViewportMatrixElementm31 = vp->originY + vp->height / 2, - .ViewportMatrixElementm32 = (vp->maxDepth + vp->minDepth) / 2, - .XMinClipGuardband = -1.0f, - .XMaxClipGuardband = 1.0f, - .YMinClipGuardband = -1.0f, - .YMaxClipGuardband = 1.0f, - .XMinViewPort = vp->originX, - .XMaxViewPort = vp->originX + vp->width - 1, - .YMinViewPort = vp->originY, - .YMaxViewPort = vp->originY + vp->height - 1, - }; - - struct GEN7_CC_VIEWPORT cc_viewport = { - .MinimumDepth = vp->minDepth, - .MaximumDepth = vp->maxDepth - }; - - /* Since xmax and ymax are inclusive, we have to have xmax < xmin or - * ymax < ymin for empty clips. In case clip x, y, width height are all - * 0, the clamps below produce 0 for xmin, ymin, xmax, ymax, which isn't - * what we want. Just special case empty clips and produce a canonical - * empty clip. */ - static const struct GEN7_SCISSOR_RECT empty_scissor = { - .ScissorRectangleYMin = 1, - .ScissorRectangleXMin = 1, - .ScissorRectangleYMax = 0, - .ScissorRectangleXMax = 0 - }; - - const int max = 0xffff; - struct GEN7_SCISSOR_RECT scissor = { - /* Do this math using int64_t so overflow gets clamped correctly. */ - .ScissorRectangleYMin = clamp_int64(s->offset.y, 0, max), - .ScissorRectangleXMin = clamp_int64(s->offset.x, 0, max), - .ScissorRectangleYMax = clamp_int64((uint64_t) s->offset.y + s->extent.height - 1, 0, max), - .ScissorRectangleXMax = clamp_int64((uint64_t) s->offset.x + s->extent.width - 1, 0, max) - }; - - GEN8_SF_CLIP_VIEWPORT_pack(NULL, state->sf_clip_vp.map + i * 64, &sf_clip_viewport); - GEN7_CC_VIEWPORT_pack(NULL, state->cc_vp.map + i * 32, &cc_viewport); - - if (s->extent.width <= 0 || s->extent.height <= 0) { - GEN7_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &empty_scissor); - } else { - GEN7_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &scissor); - } - } - - *pState = anv_dynamic_vp_state_to_handle(state); - - return VK_SUCCESS; -} - -void anv_DestroyDynamicViewportState( - VkDevice _device, - VkDynamicViewportState _vp_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_vp_state, vp_state, _vp_state); - - anv_state_pool_free(&device->dynamic_state_pool, vp_state->sf_clip_vp); - anv_state_pool_free(&device->dynamic_state_pool, vp_state->cc_vp); - anv_state_pool_free(&device->dynamic_state_pool, vp_state->scissor); - - anv_device_free(device, vp_state); -} - -void anv_DestroyDynamicRasterState( - VkDevice _device, - VkDynamicRasterState _rs_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_rs_state, rs_state, _rs_state); - - anv_device_free(device, rs_state); -} - -VkResult anv_CreateDynamicColorBlendState( - VkDevice _device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_cb_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN7_COLOR_CALC_STATE color_calc_state = { - .BlendConstantColorRed = pCreateInfo->blendConst[0], - .BlendConstantColorGreen = pCreateInfo->blendConst[1], - .BlendConstantColorBlue = pCreateInfo->blendConst[2], - .BlendConstantColorAlpha = pCreateInfo->blendConst[3] - }; - - GEN7_COLOR_CALC_STATE_pack(NULL, state->color_calc_state, &color_calc_state); - - *pState = anv_dynamic_cb_state_to_handle(state); - - return VK_SUCCESS; -} - -void anv_DestroyDynamicColorBlendState( - VkDevice _device, - VkDynamicColorBlendState _cb_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_cb_state, cb_state, _cb_state); - - anv_device_free(device, cb_state); -} - -void anv_DestroyDynamicDepthStencilState( - VkDevice _device, - VkDynamicDepthStencilState _ds_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_ds_state, ds_state, _ds_state); - - anv_device_free(device, ds_state); -} - -#endif - VkResult anv_CreateFramebuffer( VkDevice _device, const VkFramebufferCreateInfo* pCreateInfo, From 033a37f5913ec453a9e007075913fecc4868dad5 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 09:57:51 -0700 Subject: [PATCH 62/76] vk/0.170.2: Update VkPhysicalDeviceLimits --- include/vulkan/vulkan.h | 17 ++++++++++++++++- src/vulkan/anv_device.c | 9 ++++++++- 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index f453553ae5c..b2cdf3c66ab 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -876,6 +876,17 @@ typedef enum { } VkImageCreateFlagBits; typedef VkFlags VkImageCreateFlags; +typedef enum { + 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, +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + typedef enum { VK_QUEUE_GRAPHICS_BIT = 0x00000001, VK_QUEUE_COMPUTE_BIT = 0x00000002, @@ -1214,12 +1225,14 @@ typedef struct { uint32_t maxImageDimension3D; uint32_t maxImageDimensionCube; uint32_t maxImageArrayLayers; + VkSampleCountFlags sampleCounts; uint32_t maxTexelBufferSize; uint32_t maxUniformBufferSize; uint32_t maxStorageBufferSize; uint32_t maxPushConstantsSize; uint32_t maxMemoryAllocationCount; VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; uint32_t maxBoundDescriptorSets; uint32_t maxDescriptorSets; uint32_t maxPerStageDescriptorSamplers; @@ -1229,10 +1242,13 @@ typedef struct { uint32_t maxPerStageDescriptorStorageImages; uint32_t maxDescriptorSetSamplers; uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; uint32_t maxDescriptorSetSampledImages; uint32_t maxDescriptorSetStorageImages; uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; uint32_t maxVertexInputAttributeOffset; uint32_t maxVertexInputBindingStride; uint32_t maxVertexOutputComponents; @@ -1266,7 +1282,6 @@ typedef struct { float maxSamplerLodBias; float maxSamplerAnisotropy; uint32_t maxViewports; - uint32_t maxDynamicViewportStates; uint32_t maxViewportDimensions[2]; float viewportBoundsRange[2]; uint32_t viewportSubPixelBits; diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index be744bb9b55..71ec45089db 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -330,12 +330,17 @@ VkResult anv_GetPhysicalDeviceLimits( .maxImageDimension3D = (1 << 10), .maxImageDimensionCube = (1 << 14), .maxImageArrayLayers = (1 << 10), + + /* Broadwell supports 1, 2, 4, and 8 samples. */ + .sampleCounts = 4, + .maxTexelBufferSize = (1 << 14), .maxUniformBufferSize = UINT32_MAX, .maxStorageBufferSize = UINT32_MAX, .maxPushConstantsSize = MAX_PUSH_CONSTANTS_SIZE, .maxMemoryAllocationCount = UINT32_MAX, .bufferImageGranularity = 64, /* A cache line */ + .sparseAddressSpaceSize = 0, .maxBoundDescriptorSets = MAX_SETS, .maxDescriptorSets = UINT32_MAX, .maxPerStageDescriptorSamplers = 64, @@ -345,10 +350,13 @@ VkResult anv_GetPhysicalDeviceLimits( .maxPerStageDescriptorStorageImages = 64, .maxDescriptorSetSamplers = 256, .maxDescriptorSetUniformBuffers = 256, + .maxDescriptorSetUniformBuffersDynamic = 256, .maxDescriptorSetStorageBuffers = 256, + .maxDescriptorSetStorageBuffersDynamic = 256, .maxDescriptorSetSampledImages = 256, .maxDescriptorSetStorageImages = 256, .maxVertexInputAttributes = 32, + .maxVertexInputBindings = 32, .maxVertexInputAttributeOffset = 256, .maxVertexInputBindingStride = 256, .maxVertexOutputComponents = 32, @@ -390,7 +398,6 @@ VkResult anv_GetPhysicalDeviceLimits( .maxSamplerLodBias = 16, .maxSamplerAnisotropy = 16, .maxViewports = MAX_VIEWPORTS, - .maxDynamicViewportStates = UINT32_MAX, .maxViewportDimensions = { (1 << 14), (1 << 14) }, .viewportBoundsRange = { -1.0, 1.0 }, /* FIXME */ .viewportSubPixelBits = 13, /* We take a float? */ From 545f5cc6e1202ebf1777f63d25741e64e3699a97 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:05:02 -0700 Subject: [PATCH 63/76] vk/0.170.2: Update VkPhysicalDeviceFeatures --- include/vulkan/vulkan.h | 17 +++++------------ src/vulkan/anv_device.c | 9 ++++----- 2 files changed, 9 insertions(+), 17 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index b2cdf3c66ab..467a20619dd 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1152,7 +1152,7 @@ typedef struct { VkBool32 sampleRateShading; VkBool32 dualSourceBlend; VkBool32 logicOp; - VkBool32 instancedDrawIndirect; + VkBool32 multiDrawIndirect; VkBool32 depthClip; VkBool32 depthBiasClamp; VkBool32 fillModeNonSolid; @@ -1162,6 +1162,7 @@ typedef struct { VkBool32 textureCompressionETC2; VkBool32 textureCompressionASTC_LDR; VkBool32 textureCompressionBC; + VkBool32 occlusionQueryNonConservative; VkBool32 pipelineStatisticsQuery; VkBool32 vertexSideEffects; VkBool32 tessellationSideEffects; @@ -1169,11 +1170,9 @@ typedef struct { VkBool32 fragmentSideEffects; VkBool32 shaderTessellationPointSize; VkBool32 shaderGeometryPointSize; - VkBool32 shaderTextureGatherExtended; + VkBool32 shaderImageGatherExtended; VkBool32 shaderStorageImageExtendedFormats; VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageBufferArrayConstantIndexing; - VkBool32 shaderStorageImageArrayConstantIndexing; VkBool32 shaderUniformBufferArrayDynamicIndexing; VkBool32 shaderSampledImageArrayDynamicIndexing; VkBool32 shaderStorageBufferArrayDynamicIndexing; @@ -1182,11 +1181,11 @@ typedef struct { VkBool32 shaderCullDistance; VkBool32 shaderFloat64; VkBool32 shaderInt64; - VkBool32 shaderFloat16; VkBool32 shaderInt16; VkBool32 shaderResourceResidency; VkBool32 shaderResourceMinLOD; - VkBool32 sparse; + VkBool32 alphaToOne; + VkBool32 sparseBinding; VkBool32 sparseResidencyBuffer; VkBool32 sparseResidencyImage2D; VkBool32 sparseResidencyImage3D; @@ -1194,12 +1193,6 @@ typedef struct { VkBool32 sparseResidency4Samples; VkBool32 sparseResidency8Samples; VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyStandard2DBlockShape; - VkBool32 sparseResidencyStandard2DMSBlockShape; - VkBool32 sparseResidencyStandard3DBlockShape; - VkBool32 sparseResidencyAlignedMipSize; - VkBool32 sparseResidencyNonResident; - VkBool32 sparseResidencyNonResidentStrict; VkBool32 sparseResidencyAliased; } VkPhysicalDeviceFeatures; diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 71ec45089db..6473765cebc 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -278,7 +278,7 @@ VkResult anv_GetPhysicalDeviceFeatures( .sampleRateShading = false, .dualSourceBlend = true, .logicOp = true, - .instancedDrawIndirect = true, + .multiDrawIndirect = true, .depthClip = false, .depthBiasClamp = false, .fillModeNonSolid = true, @@ -288,6 +288,7 @@ VkResult anv_GetPhysicalDeviceFeatures( .textureCompressionETC2 = true, .textureCompressionASTC_LDR = true, .textureCompressionBC = true, + .occlusionQueryNonConservative = false, /* FINISHME */ .pipelineStatisticsQuery = true, .vertexSideEffects = false, .tessellationSideEffects = false, @@ -295,11 +296,9 @@ VkResult anv_GetPhysicalDeviceFeatures( .fragmentSideEffects = false, .shaderTessellationPointSize = false, .shaderGeometryPointSize = true, - .shaderTextureGatherExtended = true, + .shaderImageGatherExtended = true, .shaderStorageImageExtendedFormats = false, .shaderStorageImageMultisample = false, - .shaderStorageBufferArrayConstantIndexing = false, - .shaderStorageImageArrayConstantIndexing = false, .shaderUniformBufferArrayDynamicIndexing = true, .shaderSampledImageArrayDynamicIndexing = false, .shaderStorageBufferArrayDynamicIndexing = false, @@ -308,8 +307,8 @@ VkResult anv_GetPhysicalDeviceFeatures( .shaderCullDistance = false, .shaderFloat64 = false, .shaderInt64 = false, - .shaderFloat16 = false, .shaderInt16 = false, + .alphaToOne = true, }; return VK_SUCCESS; From 98c2bb69172944e909922f00422bd235b8e543cc Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:15:59 -0700 Subject: [PATCH 64/76] vk/0.170.2: Update VkFormatProperties --- include/vulkan/vulkan.h | 4 +++- src/vulkan/anv_formats.c | 18 ++++++++++++++---- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 467a20619dd..1bcc31c59d9 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -851,7 +851,8 @@ typedef enum { 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_CONVERSION_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800, } VkFormatFeatureFlagBits; typedef VkFlags VkFormatFeatureFlags; @@ -1199,6 +1200,7 @@ typedef struct { typedef struct { VkFormatFeatureFlags linearTilingFeatures; VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; } VkFormatProperties; typedef struct { diff --git a/src/vulkan/anv_formats.c b/src/vulkan/anv_formats.c index cae575bb04b..8f36bc9a7ce 100644 --- a/src/vulkan/anv_formats.c +++ b/src/vulkan/anv_formats.c @@ -252,6 +252,7 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d { const struct surface_format_info *info; int gen; + VkFormatFeatureFlags flags; if (format == NULL) return VK_ERROR_INVALID_VALUE; @@ -267,6 +268,10 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d if (anv_format_is_depth_or_stencil(format)) { tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; tiled |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + tiled |= VK_FORMAT_FEATURE_BLIT_SOURCE_BIT; + if (format->depth_format) { + tiled |= VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT; + } } else { /* The surface_formats table only contains color formats */ info = &surface_formats[format->surface_format]; @@ -274,12 +279,16 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d goto unsupported; if (info->sampling <= gen) { - linear |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + flags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | + VK_FORMAT_FEATURE_BLIT_SOURCE_BIT; + linear |= flags; + tiled |= flags; } if (info->render_target <= gen) { - linear |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; - tiled |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + flags = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | + VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT; + linear |= flags; + tiled |= flags; } if (info->alpha_blend <= gen) { linear |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT; @@ -292,6 +301,7 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d out_properties->linearTilingFeatures = linear; out_properties->optimalTilingFeatures = tiled; + out_properties->bufferFeatures = 0; /* FINISHME */ return VK_SUCCESS; From 81e1dcc42c33d306d490b886b74df62e48eead99 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:28:30 -0700 Subject: [PATCH 65/76] vk/0.170.2: Update VkImageFormatProperties --- include/vulkan/vulkan.h | 7 +++++-- src/vulkan/anv_formats.c | 43 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 46 insertions(+), 4 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 1bcc31c59d9..26827b6847f 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1210,8 +1210,11 @@ typedef struct { } VkExtent3D; typedef struct { - uint64_t maxResourceSize; - uint32_t maxSamples; + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArraySize; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; } VkImageFormatProperties; typedef struct { diff --git a/src/vulkan/anv_formats.c b/src/vulkan/anv_formats.c index 8f36bc9a7ce..f5bae0ae0aa 100644 --- a/src/vulkan/anv_formats.c +++ b/src/vulkan/anv_formats.c @@ -344,6 +344,9 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( const struct anv_format *format = anv_format_for_vk_format(_format); VkFormatProperties format_props; VkFormatFeatureFlags format_feature_flags; + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArraySize; VkResult result; result = anv_physical_device_get_format_properties(physical_device, format, @@ -362,6 +365,35 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( unreachable("bad VkImageTiling"); } + switch (type) { + default: + unreachable("bad VkImageType"); + case VK_IMAGE_TYPE_1D: + maxExtent.width = 16384; + maxExtent.height = 1; + maxExtent.depth = 1; + maxMipLevels = 15; /* log2(maxWidth) + 1 */ + maxArraySize = 2048; + break; + case VK_IMAGE_TYPE_2D: + /* FINISHME: Does this really differ for cube maps? The documentation + * for RENDER_SURFACE_STATE suggests so. + */ + maxExtent.width = 16384; + maxExtent.height = 16384; + maxExtent.depth = 1; + maxMipLevels = 15; /* log2(maxWidth) + 1 */ + maxArraySize = 2048; + break; + case VK_IMAGE_TYPE_3D: + maxExtent.width = 2048; + maxExtent.height = 2048; + maxExtent.depth = 2048; + maxMipLevels = 12; /* log2(maxWidth) + 1 */ + maxArraySize = 1; + break; + } + if (usage & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT) { /* Meta implements transfers by sampling from the source image. */ if (!(format_feature_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { @@ -415,8 +447,12 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( } *pImageFormatProperties = (VkImageFormatProperties) { + .maxExtent = maxExtent, + .maxMipLevels = maxMipLevels, + .maxArraySize = maxArraySize, + /* FINISHME: Support multisampling */ - .maxSamples = 1, + .sampleCounts = VK_SAMPLE_COUNT_1_BIT, /* FINISHME: Accurately calculate * VkImageFormatProperties::maxResourceSize. @@ -428,7 +464,10 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( unsupported: *pImageFormatProperties = (VkImageFormatProperties) { - .maxSamples = 0, + .maxExtent = { 0, 0, 0 }, + .maxMipLevels = 0, + .maxArraySize = 0, + .sampleCounts = 0, .maxResourceSize = 0, }; From d48e71ce55cd63735bedb41c9754b30571a06e8f Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:36:46 -0700 Subject: [PATCH 66/76] vk/0.170.2: Update VkPhysicalDeviceProperties --- include/vulkan/vulkan.h | 16 +++++++++++----- src/vulkan/anv_device.c | 23 ++++++++--------------- 2 files changed, 19 insertions(+), 20 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 26827b6847f..c4ed1ec0cd1 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1316,6 +1316,15 @@ typedef struct { float lineWidthGranularity; } VkPhysicalDeviceLimits; +typedef struct { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMSBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResident; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + typedef struct { uint32_t apiVersion; uint32_t driverVersion; @@ -1324,6 +1333,8 @@ typedef struct { VkPhysicalDeviceType deviceType; char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; } VkPhysicalDeviceProperties; typedef struct { @@ -2082,7 +2093,6 @@ typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, ui typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties); typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); @@ -2254,10 +2264,6 @@ VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -VkResult VKAPI vkGetPhysicalDeviceLimits( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceLimits* pLimits); - VkResult VKAPI vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 6473765cebc..310a5b91131 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -314,16 +314,16 @@ VkResult anv_GetPhysicalDeviceFeatures( return VK_SUCCESS; } -VkResult anv_GetPhysicalDeviceLimits( +VkResult anv_GetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, - VkPhysicalDeviceLimits* pLimits) + VkPhysicalDeviceProperties* pProperties) { - ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); - const struct brw_device_info *devinfo = physical_device->info; + ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice); + const struct brw_device_info *devinfo = pdevice->info; - anv_finishme("Get correct values for PhysicalDeviceLimits"); + anv_finishme("Get correct values for VkPhysicalDeviceLimits"); - *pLimits = (VkPhysicalDeviceLimits) { + VkPhysicalDeviceLimits limits = { .maxImageDimension1D = (1 << 14), .maxImageDimension2D = (1 << 14), .maxImageDimension3D = (1 << 10), @@ -433,21 +433,14 @@ VkResult anv_GetPhysicalDeviceLimits( .lineWidthGranularity = (1.0 / 128.0), }; - return VK_SUCCESS; -} - -VkResult anv_GetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) -{ - ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice); - *pProperties = (VkPhysicalDeviceProperties) { .apiVersion = VK_MAKE_VERSION(0, 138, 1), .driverVersion = 1, .vendorId = 0x8086, .deviceId = pdevice->chipset_id, .deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, + .limits = limits, + .sparseProperties = {0}, /* Broadwell doesn't do sparse. */ }; strcpy(pProperties->deviceName, pdevice->name); From f4295b3cca5dc6b8dbe676c1ba75a4083a3b6df2 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:42:59 -0700 Subject: [PATCH 67/76] vk/0.170.2: Update VkImageCreateInfo --- include/vulkan/vulkan-0.170.2.h | 1 - include/vulkan/vulkan.h | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/include/vulkan/vulkan-0.170.2.h b/include/vulkan/vulkan-0.170.2.h index 03bcefea50a..6fdd806509c 100644 --- a/include/vulkan/vulkan-0.170.2.h +++ b/include/vulkan/vulkan-0.170.2.h @@ -1512,7 +1512,6 @@ typedef struct { VkSharingMode sharingMode; uint32_t queueFamilyCount; const uint32_t* pQueueFamilyIndices; - VkImageLayout initialLayout; } VkImageCreateInfo; typedef struct { diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index c4ed1ec0cd1..65da0a89c93 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1516,6 +1516,7 @@ typedef struct { VkSharingMode sharingMode; uint32_t queueFamilyCount; const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; } VkImageCreateInfo; typedef struct { From 82259f88ddc862190b2e822f0f4b87b106e161fa Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:43:44 -0700 Subject: [PATCH 68/76] vk/0.170.2: Update VkImageViewCreateInfo --- include/vulkan/vulkan.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 65da0a89c93..19916a14526 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1549,6 +1549,7 @@ typedef struct { VkFormat format; VkChannelMapping channels; VkImageSubresourceRange subresourceRange; + VkImageViewCreateFlags flags; } VkImageViewCreateInfo; typedef struct { From a3bc07c23b4381aa91569937636e47ead112cf3c Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:44:40 -0700 Subject: [PATCH 69/76] vk/0.170.2: Update VkAttachmentDescription --- include/vulkan/vulkan.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 19916a14526..00dbf3dd69c 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1018,6 +1018,11 @@ typedef enum { } VkShaderStageFlagBits; typedef VkFlags VkShaderStageFlags; +typedef enum { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + typedef enum { VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, } VkSubpassDescriptionFlagBits; @@ -1888,6 +1893,7 @@ typedef struct { VkAttachmentStoreOp stencilStoreOp; VkImageLayout initialLayout; VkImageLayout finalLayout; + VkAttachmentDescriptionFlags flags; } VkAttachmentDescription; typedef struct { From 92e7bd361065ff3dad863736456f3729952bf5a2 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:45:41 -0700 Subject: [PATCH 70/76] vk/0.170.2: Update vkCreateDescriptorPool Nothing to do. In Mesa the pool is a stub. --- include/vulkan/vulkan-0.170.2.h | 1 + include/vulkan/vulkan.h | 6 +++--- src/vulkan/anv_device.c | 2 -- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/include/vulkan/vulkan-0.170.2.h b/include/vulkan/vulkan-0.170.2.h index 6fdd806509c..03bcefea50a 100644 --- a/include/vulkan/vulkan-0.170.2.h +++ b/include/vulkan/vulkan-0.170.2.h @@ -1512,6 +1512,7 @@ typedef struct { VkSharingMode sharingMode; uint32_t queueFamilyCount; const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; } VkImageCreateInfo; typedef struct { diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 00dbf3dd69c..89963aea55c 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1837,6 +1837,8 @@ typedef struct { typedef struct { VkStructureType sType; const void* pNext; + VkDescriptorPoolUsage poolUsage; + uint32_t maxSets; uint32_t count; const VkDescriptorTypeCount* pTypeCount; } VkDescriptorPoolCreateInfo; @@ -2176,7 +2178,7 @@ typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCr typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); @@ -2643,8 +2645,6 @@ void VKAPI vkDestroyDescriptorSetLayout( VkResult VKAPI vkCreateDescriptorPool( VkDevice device, - VkDescriptorPoolUsage poolUsage, - uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 310a5b91131..dd0aac48303 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1591,8 +1591,6 @@ void anv_DestroyDescriptorSetLayout( VkResult anv_CreateDescriptorPool( VkDevice device, - VkDescriptorPoolUsage poolUsage, - uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { From 8dee32e71f0ccbdf2b9404fe553a83da8bea79dc Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 10:58:55 -0700 Subject: [PATCH 71/76] vk/0.170: Update VkDescriptorInfo Ignore the new bufferInfo field with a anv_finishme. --- include/vulkan/vulkan.h | 7 +++++++ src/vulkan/anv_device.c | 10 ++++++++++ 2 files changed, 17 insertions(+) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 89963aea55c..dcba29cb426 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -1843,11 +1843,18 @@ typedef struct { const VkDescriptorTypeCount* pTypeCount; } VkDescriptorPoolCreateInfo; +typedef struct { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + typedef struct { VkBufferView bufferView; VkSampler sampler; VkImageView imageView; VkImageLayout imageLayout; + VkDescriptorBufferInfo bufferInfo; } VkDescriptorInfo; typedef struct { diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index dd0aac48303..b12fabc2007 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -1701,6 +1701,16 @@ void anv_UpdateDescriptorSets( const VkWriteDescriptorSet *write = &pDescriptorWrites[i]; ANV_FROM_HANDLE(anv_descriptor_set, set, write->destSet); + for (uint32_t j = 0; j < write->count; ++j) { + const VkDescriptorBufferInfo *binfo + = &write->pDescriptors[j].bufferInfo; + + if (binfo->buffer.handle || binfo->offset || binfo->range) { + anv_finishme("VkWriteDesciptorSet::bufferInfo"); + break; + } + } + switch (write->descriptorType) { case VK_DESCRIPTOR_TYPE_SAMPLER: case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: From f9c948ed00787c56bac265dc934049ed67a1cd61 Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 11:36:51 -0700 Subject: [PATCH 72/76] vk/0.170.2: Update VkResult Version 0.170.2 removes most of the error enums. In many cases, I had to replace an error with a less accurate (or even incorrect) one. In other cases, the error path is replaced with an assertion. --- include/vulkan/vulkan.h | 42 +++++----------------- src/vulkan/anv_device.c | 68 ++++++++++++++++++++++-------------- src/vulkan/anv_formats.c | 3 +- src/vulkan/anv_image.c | 27 +++++--------- src/vulkan/anv_query.c | 7 ++-- src/vulkan/anv_util.c | 35 +++++-------------- src/vulkan/anv_wsi_wayland.c | 27 ++++++++------ src/vulkan/anv_wsi_x11.c | 40 +++++++++------------ src/vulkan/gen7_pipeline.c | 3 +- 9 files changed, 107 insertions(+), 145 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index dcba29cb426..1a572136340 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -128,41 +128,17 @@ typedef enum { VK_EVENT_SET = 4, VK_EVENT_RESET = 5, VK_INCOMPLETE = 6, - VK_ERROR_UNKNOWN = -1, - VK_ERROR_UNAVAILABLE = -2, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_OUT_OF_HOST_MEMORY = -4, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -5, - VK_ERROR_DEVICE_ALREADY_CREATED = -6, - VK_ERROR_DEVICE_LOST = -7, - VK_ERROR_INVALID_POINTER = -8, - VK_ERROR_INVALID_VALUE = -9, - VK_ERROR_INVALID_HANDLE = -10, - VK_ERROR_INVALID_ORDINAL = -11, - VK_ERROR_INVALID_MEMORY_SIZE = -12, - VK_ERROR_INVALID_EXTENSION = -13, - VK_ERROR_INVALID_FLAGS = -14, - VK_ERROR_INVALID_ALIGNMENT = -15, - VK_ERROR_INVALID_FORMAT = -16, - VK_ERROR_INVALID_IMAGE = -17, - VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18, - VK_ERROR_INVALID_QUEUE_TYPE = -19, - VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -20, - VK_ERROR_BAD_SHADER_CODE = -21, - VK_ERROR_BAD_PIPELINE_DATA = -22, - VK_ERROR_NOT_MAPPABLE = -23, - VK_ERROR_MEMORY_MAP_FAILED = -24, - VK_ERROR_MEMORY_UNMAP_FAILED = -25, - VK_ERROR_INCOMPATIBLE_DEVICE = -26, - VK_ERROR_INCOMPATIBLE_DRIVER = -27, - VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -28, - VK_ERROR_BUILDING_COMMAND_BUFFER = -29, - VK_ERROR_MEMORY_NOT_BOUND = -30, - VK_ERROR_INCOMPATIBLE_QUEUE = -31, - VK_ERROR_INVALID_LAYER = -32, - VK_RESULT_BEGIN_RANGE = VK_ERROR_INVALID_LAYER, + 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_INCOMPATIBLE_DRIVER = -8, + VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER, VK_RESULT_END_RANGE = VK_INCOMPLETE, - VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1), + VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1), VK_RESULT_MAX_ENUM = 0x7FFFFFFF } VkResult; diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index b12fabc2007..4e677054afe 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -43,42 +43,49 @@ anv_physical_device_init(struct anv_physical_device *device, fd = open(path, O_RDWR | O_CLOEXEC); if (fd < 0) - return vk_errorf(VK_ERROR_UNAVAILABLE, "failed to open %s: %m", path); + return vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to open %s: %m", path); device->_loader_data.loaderMagic = ICD_LOADER_MAGIC; device->instance = instance; device->path = path; - + device->chipset_id = anv_gem_get_param(fd, I915_PARAM_CHIPSET_ID); if (!device->chipset_id) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "failed to get chipset id: %m"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to get chipset id: %m"); goto fail; } device->name = brw_get_device_name(device->chipset_id); device->info = brw_get_device_info(device->chipset_id, -1); if (!device->info) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "failed to get device info"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to get device info"); goto fail; } if (anv_gem_get_aperture(fd, &device->aperture_size) == -1) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "failed to get aperture size: %m"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to get aperture size: %m"); goto fail; } if (!anv_gem_get_param(fd, I915_PARAM_HAS_WAIT_TIMEOUT)) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "kernel missing gem wait"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "kernel missing gem wait"); goto fail; } if (!anv_gem_get_param(fd, I915_PARAM_HAS_EXECBUF2)) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "kernel missing execbuf2"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "kernel missing execbuf2"); goto fail; } if (!anv_gem_get_param(fd, I915_PARAM_HAS_LLC)) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "non-llc gpu"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "non-llc gpu"); goto fail; } @@ -148,7 +155,7 @@ VkResult anv_CreateInstance( } } if (!found) - return vk_error(VK_ERROR_INVALID_EXTENSION); + return vk_error(VK_ERROR_EXTENSION_NOT_PRESENT); } if (pCreateInfo->pAllocCb) { @@ -581,7 +588,7 @@ VkResult anv_CreateDevice( } } if (!found) - return vk_error(VK_ERROR_INVALID_EXTENSION); + return vk_error(VK_ERROR_EXTENSION_NOT_PRESENT); } anv_set_dispatch_gen(physical_device->info->gen); @@ -639,7 +646,7 @@ VkResult anv_CreateDevice( fail_device: anv_device_free(device, device); - return vk_error(VK_ERROR_UNAVAILABLE); + return vk_error(VK_ERROR_INITIALIZATION_FAILED); } void anv_DestroyDevice( @@ -720,7 +727,7 @@ VkResult anv_EnumerateInstanceLayerProperties( } /* None supported at this time */ - return vk_error(VK_ERROR_INVALID_LAYER); + return vk_error(VK_ERROR_LAYER_NOT_PRESENT); } VkResult anv_EnumerateDeviceLayerProperties( @@ -734,7 +741,7 @@ VkResult anv_EnumerateDeviceLayerProperties( } /* None supported at this time */ - return vk_error(VK_ERROR_INVALID_LAYER); + return vk_error(VK_ERROR_LAYER_NOT_PRESENT); } VkResult anv_GetDeviceQueue( @@ -769,13 +776,19 @@ VkResult anv_QueueSubmit( assert(cmd_buffer->level == VK_CMD_BUFFER_LEVEL_PRIMARY); ret = anv_gem_execbuffer(device, &cmd_buffer->execbuf2.execbuf); - if (ret != 0) - return vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + if (ret != 0) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "execbuf2 failed: %m"); + } if (fence) { ret = anv_gem_execbuffer(device, &fence->execbuf); - if (ret != 0) - return vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + if (ret != 0) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "execbuf2 failed: %m"); + } } for (uint32_t i = 0; i < cmd_buffer->execbuf2.bo_count; i++) @@ -838,14 +851,16 @@ VkResult anv_DeviceWaitIdle( ret = anv_gem_execbuffer(device, &execbuf); if (ret != 0) { - result = vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + /* We don't know the real error. */ + result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, "execbuf2 failed: %m"); goto fail; } timeout = INT64_MAX; ret = anv_gem_wait(device, bo->gem_handle, &timeout); if (ret != 0) { - result = vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + /* We don't know the real error. */ + result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, "execbuf2 failed: %m"); goto fail; } @@ -901,10 +916,8 @@ VkResult anv_AllocMemory( assert(pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO); - if (pAllocInfo->memoryTypeIndex != 0) { - /* We support exactly one memory heap. */ - return vk_error(VK_ERROR_INVALID_VALUE); - } + /* We support exactly one memory heap. */ + assert(pAllocInfo->memoryTypeIndex == 0); /* FINISHME: Fail if allocation request exceeds heap size. */ @@ -1243,10 +1256,13 @@ VkResult anv_WaitForFences( for (uint32_t i = 0; i < fenceCount; i++) { ANV_FROM_HANDLE(anv_fence, fence, pFences[i]); ret = anv_gem_wait(device, fence->bo.gem_handle, &t); - if (ret == -1 && errno == ETIME) + if (ret == -1 && errno == ETIME) { return VK_TIMEOUT; - else if (ret == -1) - return vk_errorf(VK_ERROR_UNKNOWN, "gem wait failed: %m"); + } else if (ret == -1) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "gem wait failed: %m"); + } } return VK_SUCCESS; diff --git a/src/vulkan/anv_formats.c b/src/vulkan/anv_formats.c index f5bae0ae0aa..944e05f1476 100644 --- a/src/vulkan/anv_formats.c +++ b/src/vulkan/anv_formats.c @@ -254,8 +254,7 @@ anv_physical_device_get_format_properties(struct anv_physical_device *physical_d int gen; VkFormatFeatureFlags flags; - if (format == NULL) - return VK_ERROR_INVALID_VALUE; + assert(format != NULL); gen = physical_device->info->gen * 10; if (physical_device->info->is_haswell) diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 8522d0e8318..014a9b9b342 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -102,10 +102,7 @@ static const struct anv_tile_info { [WMAJOR] = { 128, 32, 4096 }, }; -/** - * Return -1 on failure. - */ -static int8_t +static uint8_t anv_image_choose_tile_mode(const struct anv_image_create_info *anv_info) { if (anv_info->force_tile_mode) @@ -117,11 +114,8 @@ anv_image_choose_tile_mode(const struct anv_image_create_info *anv_info) switch (anv_info->vk_info->tiling) { case VK_IMAGE_TILING_LINEAR: - if (unlikely(anv_info->vk_info->format == VK_FORMAT_S8_UINT)) { - return -1; - } else { - return LINEAR; - } + assert(anv_info->vk_info->format != VK_FORMAT_S8_UINT); + return LINEAR; case VK_IMAGE_TILING_OPTIMAL: if (unlikely(anv_info->vk_info->format == VK_FORMAT_S8_UINT)) { return WMAJOR; @@ -153,10 +147,7 @@ anv_image_make_surface(const struct anv_image_create_info *create_info, const VkExtent3D *restrict extent = &create_info->vk_info->extent; const uint32_t levels = create_info->vk_info->mipLevels; const uint32_t array_size = create_info->vk_info->arraySize; - - const int8_t tile_mode = anv_image_choose_tile_mode(create_info); - if (tile_mode == -1) - return vk_error(VK_ERROR_INVALID_IMAGE); + const uint8_t tile_mode = anv_image_choose_tile_mode(create_info); const struct anv_tile_info *tile_info = &anv_tile_info_table[tile_mode]; @@ -305,12 +296,10 @@ anv_image_create(VkDevice _device, const struct anv_surf_type_limits *limits = &anv_surf_type_limits[surf_type]; - if (extent->width > limits->width || - extent->height > limits->height || - extent->depth > limits->depth) { - /* TODO(chadv): What is the correct error? */ - return vk_errorf(VK_ERROR_INVALID_MEMORY_SIZE, "image extent is too large"); - } + /* Errors should be caught by VkImageFormatProperties. */ + assert(extent->width <= limits->width); + assert(extent->height <= limits->height); + assert(extent->depth <= limits->depth); image = anv_device_alloc(device, sizeof(*image), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); diff --git a/src/vulkan/anv_query.c b/src/vulkan/anv_query.c index 9464531b8c5..68535b40cac 100644 --- a/src/vulkan/anv_query.c +++ b/src/vulkan/anv_query.c @@ -120,8 +120,11 @@ VkResult anv_GetQueryPoolResults( if (flags & VK_QUERY_RESULT_WAIT_BIT) { ret = anv_gem_wait(device, pool->bo.gem_handle, &timeout); - if (ret == -1) - return vk_errorf(VK_ERROR_UNKNOWN, "gem_wait failed %m"); + if (ret == -1) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "gem_wait failed %m"); + } } for (uint32_t i = 0; i < queryCount; i++) { diff --git a/src/vulkan/anv_util.c b/src/vulkan/anv_util.c index 4c8fadcc805..628e399cb3e 100644 --- a/src/vulkan/anv_util.c +++ b/src/vulkan/anv_util.c @@ -92,39 +92,20 @@ __vk_errorf(VkResult error, const char *file, int line, const char *format, ...) const char *error_str; switch ((int32_t)error) { - ERROR_CASE(VK_ERROR_UNKNOWN) - ERROR_CASE(VK_ERROR_UNAVAILABLE) - ERROR_CASE(VK_ERROR_INITIALIZATION_FAILED) + + /* Core errors */ ERROR_CASE(VK_ERROR_OUT_OF_HOST_MEMORY) ERROR_CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY) - ERROR_CASE(VK_ERROR_DEVICE_ALREADY_CREATED) + ERROR_CASE(VK_ERROR_INITIALIZATION_FAILED) ERROR_CASE(VK_ERROR_DEVICE_LOST) - ERROR_CASE(VK_ERROR_INVALID_POINTER) - ERROR_CASE(VK_ERROR_INVALID_VALUE) - ERROR_CASE(VK_ERROR_INVALID_HANDLE) - ERROR_CASE(VK_ERROR_INVALID_ORDINAL) - ERROR_CASE(VK_ERROR_INVALID_MEMORY_SIZE) - ERROR_CASE(VK_ERROR_INVALID_EXTENSION) - ERROR_CASE(VK_ERROR_INVALID_FLAGS) - ERROR_CASE(VK_ERROR_INVALID_ALIGNMENT) - ERROR_CASE(VK_ERROR_INVALID_FORMAT) - ERROR_CASE(VK_ERROR_INVALID_IMAGE) - ERROR_CASE(VK_ERROR_INVALID_DESCRIPTOR_SET_DATA) - ERROR_CASE(VK_ERROR_INVALID_QUEUE_TYPE) - ERROR_CASE(VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION) - ERROR_CASE(VK_ERROR_BAD_SHADER_CODE) - ERROR_CASE(VK_ERROR_BAD_PIPELINE_DATA) - ERROR_CASE(VK_ERROR_NOT_MAPPABLE) ERROR_CASE(VK_ERROR_MEMORY_MAP_FAILED) - ERROR_CASE(VK_ERROR_MEMORY_UNMAP_FAILED) - ERROR_CASE(VK_ERROR_INCOMPATIBLE_DEVICE) + ERROR_CASE(VK_ERROR_LAYER_NOT_PRESENT) + ERROR_CASE(VK_ERROR_EXTENSION_NOT_PRESENT) ERROR_CASE(VK_ERROR_INCOMPATIBLE_DRIVER) - ERROR_CASE(VK_ERROR_INCOMPLETE_COMMAND_BUFFER) - ERROR_CASE(VK_ERROR_BUILDING_COMMAND_BUFFER) - ERROR_CASE(VK_ERROR_MEMORY_NOT_BOUND) - ERROR_CASE(VK_ERROR_INCOMPATIBLE_QUEUE) - ERROR_CASE(VK_ERROR_INVALID_LAYER) + + /* Extension errors */ ERROR_CASE(VK_ERROR_OUT_OF_DATE_WSI) + default: assert(!"Unknown error"); error_str = "unknown error"; diff --git a/src/vulkan/anv_wsi_wayland.c b/src/vulkan/anv_wsi_wayland.c index a601ad1851f..ba3ce8a2c65 100644 --- a/src/vulkan/anv_wsi_wayland.c +++ b/src/vulkan/anv_wsi_wayland.c @@ -322,10 +322,11 @@ wsi_wl_get_surface_info(struct anv_wsi_implementation *impl, { struct wsi_wayland *wsi = (struct wsi_wayland *)impl; - if (pDataSize == NULL) - return vk_error(VK_ERROR_INVALID_POINTER); + assert(pDataSize != NULL); switch (infoType) { + default: + unreachable("bad VkSurfaceInfoTypeWSI"); case VK_SURFACE_INFO_TYPE_PROPERTIES_WSI: { VkSurfacePropertiesWSI *props = pData; @@ -384,8 +385,6 @@ wsi_wl_get_surface_info(struct anv_wsi_implementation *impl, memcpy(pData, present_modes, *pDataSize); return VK_SUCCESS; - default: - return vk_error(VK_ERROR_INVALID_VALUE); } } @@ -423,6 +422,8 @@ wsi_wl_get_swap_chain_info(struct anv_swap_chain *anv_chain, size_t size; switch (infoType) { + default: + unreachable("bad VkSwapChainInfoTypeWSI"); case VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI: { VkSwapChainImagePropertiesWSI *images = pData; @@ -441,9 +442,6 @@ wsi_wl_get_swap_chain_info(struct anv_swap_chain *anv_chain, return VK_SUCCESS; } - - default: - return vk_error(VK_ERROR_INVALID_VALUE); } } @@ -615,14 +613,16 @@ wsi_wl_image_init(struct wsi_wl_swap_chain *chain, struct wsi_wl_image *image) image->memory->bo.gem_handle, surface->stride, I915_TILING_X); if (ret) { - result = vk_error(VK_ERROR_UNKNOWN); + /* FINISHME: Choose a better error. */ + result = vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY); goto fail_mem; } int fd = anv_gem_handle_to_fd(chain->base.device, image->memory->bo.gem_handle); if (fd == -1) { - result = vk_error(VK_ERROR_UNKNOWN); + /* FINISHME: Choose a better error. */ + result = vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY); goto fail_mem; } @@ -769,8 +769,13 @@ anv_wl_init_wsi(struct anv_instance *instance) int ret = pthread_mutex_init(&wsi->mutex, NULL); if (ret != 0) { - result = (ret == ENOMEM) ? VK_ERROR_OUT_OF_HOST_MEMORY : - VK_ERROR_UNKNOWN; + if (ret == ENOMEM) { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + } else { + /* FINISHME: Choose a better error. */ + result = VK_ERROR_OUT_OF_HOST_MEMORY; + } + goto fail_alloc; } diff --git a/src/vulkan/anv_wsi_x11.c b/src/vulkan/anv_wsi_x11.c index 03aef4cbf23..d226caf0eea 100644 --- a/src/vulkan/anv_wsi_x11.c +++ b/src/vulkan/anv_wsi_x11.c @@ -54,10 +54,11 @@ x11_get_surface_info(struct anv_wsi_implementation *impl, VkSurfaceInfoTypeWSI infoType, size_t* pDataSize, void* pData) { - if (pDataSize == NULL) - return vk_error(VK_ERROR_INVALID_POINTER); + assert(pDataSize != NULL); switch (infoType) { + default: + unreachable("bad VkSurfaceInfoTypeWSI"); case VK_SURFACE_INFO_TYPE_PROPERTIES_WSI: { VkSurfacePropertiesWSI *props = pData; @@ -77,12 +78,9 @@ x11_get_surface_info(struct anv_wsi_implementation *impl, xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(conn, cookie, &err); if (!geom) { - if (err->error_code == XCB_DRAWABLE) { - return vk_error(VK_ERROR_INVALID_HANDLE); - } else { - return vk_error(VK_ERROR_UNKNOWN); - } + /* FINISHME: Choose a more accurate error. */ free(err); + return VK_ERROR_OUT_OF_DATE_WSI; } VkExtent2D extent = { geom->width, geom->height }; @@ -122,10 +120,7 @@ x11_get_surface_info(struct anv_wsi_implementation *impl, assert(*pDataSize >= sizeof(present_modes)); memcpy(pData, present_modes, *pDataSize); - return VK_SUCCESS; - default: - return vk_error(VK_ERROR_INVALID_VALUE); } } @@ -158,6 +153,8 @@ x11_get_swap_chain_info(struct anv_swap_chain *anv_chain, size_t size; switch (infoType) { + default: + unreachable("bad VkSwapChainInfoType"); case VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI: { VkSwapChainImagePropertiesWSI *images = pData; @@ -173,12 +170,8 @@ x11_get_swap_chain_info(struct anv_swap_chain *anv_chain, images[i].image = anv_image_to_handle(chain->images[i].image); *pDataSize = size; - return VK_SUCCESS; } - - default: - return vk_error(VK_ERROR_INVALID_VALUE); } } @@ -196,13 +189,9 @@ x11_acquire_next_image(struct anv_swap_chain *anv_chain, xcb_get_geometry_reply_t *geom = xcb_get_geometry_reply(chain->conn, image->geom_cookie, &err); if (!geom) { - if (err->error_code == XCB_DRAWABLE) { - /* Probably the best thing to do if our drawable goes away */ - return vk_error(VK_ERROR_OUT_OF_DATE_WSI); - } else { - return vk_error(VK_ERROR_UNKNOWN); - } + /* Probably the best thing to do if our drawable goes away */ free(err); + return vk_error(VK_ERROR_OUT_OF_DATE_WSI); } if (geom->width != chain->extent.width || @@ -366,13 +355,17 @@ x11_create_swap_chain(struct anv_wsi_implementation *impl, int ret = anv_gem_set_tiling(device, memory->bo.gem_handle, surface->stride, I915_TILING_X); if (ret) { - result = vk_errorf(VK_ERROR_UNKNOWN, "set_tiling failed: %m"); + /* FINISHME: Choose a better error. */ + result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "set_tiling failed: %m"); goto fail; } int fd = anv_gem_handle_to_fd(device, memory->bo.gem_handle); if (fd == -1) { - result = vk_errorf(VK_ERROR_UNKNOWN, "handle_to_fd failed: %m"); + /* FINISHME: Choose a better error. */ + result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "handle_to_fd failed: %m"); goto fail; } @@ -400,7 +393,8 @@ x11_create_swap_chain(struct anv_wsi_implementation *impl, chain->gc = xcb_generate_id(chain->conn); if (!chain->gc) { - result = vk_error(VK_ERROR_UNKNOWN); + /* FINISHME: Choose a better error. */ + result = vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); goto fail; } diff --git a/src/vulkan/gen7_pipeline.c b/src/vulkan/gen7_pipeline.c index 599432ed68a..affe04c526f 100644 --- a/src/vulkan/gen7_pipeline.c +++ b/src/vulkan/gen7_pipeline.c @@ -567,6 +567,5 @@ VkResult gen7_compute_pipeline_create( VkPipeline* pPipeline) { anv_finishme("primitive_id needs sbe swizzling setup"); - - return vk_error(VK_ERROR_UNAVAILABLE); + abort(); } From 0ca3c8480ddc280bc7faa8aec2db2c3cd299aade Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 11:39:49 -0700 Subject: [PATCH 73/76] vk/0.170.2: Update remaining enums --- include/vulkan/vulkan.h | 122 ++++++++++++++++++++------------------- src/vulkan/anv_formats.c | 4 +- src/vulkan/anv_image.c | 2 +- 3 files changed, 67 insertions(+), 61 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 1a572136340..62305a60116 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -44,6 +44,13 @@ extern "C" { #define VK_API_VERSION VK_MAKE_VERSION(0, 138, 2) +#if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L) + #define VK_NULL_HANDLE nullptr +#else + #define VK_NULL_HANDLE 0 +#endif + + #define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; @@ -104,14 +111,15 @@ VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) VK_DEFINE_NONDISP_HANDLE(VkCmdPool) -#define VK_LOD_CLAMP_NONE MAX_FLOAT -#define VK_LAST_MIP_LEVEL UINT32_MAX -#define VK_LAST_ARRAY_SLICE UINT32_MAX -#define VK_WHOLE_SIZE UINT64_MAX -#define VK_ATTACHMENT_UNUSED UINT32_MAX +#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_NULL_HANDLE 0 +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) #define VK_MAX_PHYSICAL_DEVICE_NAME 256 #define VK_UUID_LENGTH 16 #define VK_MAX_MEMORY_TYPES 32 @@ -147,55 +155,52 @@ typedef enum { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48, - VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, - VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, - VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF } VkStructureType; @@ -302,7 +307,7 @@ typedef enum { VK_FORMAT_R11G11B10_UFLOAT = 87, VK_FORMAT_R9G9B9E5_UFLOAT = 88, VK_FORMAT_D16_UNORM = 89, - VK_FORMAT_D24_UNORM = 90, + VK_FORMAT_D24_UNORM_X8 = 90, VK_FORMAT_D32_SFLOAT = 91, VK_FORMAT_S8_UINT = 92, VK_FORMAT_D16_UNORM_S8_UINT = 93, @@ -461,9 +466,10 @@ typedef enum { VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, - VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, + VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF } VkImageLayout; @@ -838,7 +844,7 @@ typedef enum { VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, } VkImageUsageFlagBits; diff --git a/src/vulkan/anv_formats.c b/src/vulkan/anv_formats.c index 944e05f1476..2690ff24692 100644 --- a/src/vulkan/anv_formats.c +++ b/src/vulkan/anv_formats.c @@ -120,7 +120,7 @@ static const struct anv_format anv_formats[] = { fmt(VK_FORMAT_R9G9B9E5_UFLOAT, R9G9B9E5_SHAREDEXP, .cpp = 4, .num_channels = 3), fmt(VK_FORMAT_D16_UNORM, R16_UNORM, .cpp = 2, .num_channels = 1, .depth_format = D16_UNORM), - fmt(VK_FORMAT_D24_UNORM, R24_UNORM_X8_TYPELESS, .cpp = 4, .num_channels = 1, .depth_format = D24_UNORM_X8_UINT), + fmt(VK_FORMAT_D24_UNORM_X8, R24_UNORM_X8_TYPELESS, .cpp = 4, .num_channels = 1, .depth_format = D24_UNORM_X8_UINT), fmt(VK_FORMAT_D32_SFLOAT, R32_FLOAT, .cpp = 4, .num_channels = 1, .depth_format = D32_FLOAT), fmt(VK_FORMAT_S8_UINT, R8_UINT, .cpp = 1, .num_channels = 1, .has_stencil = true), fmt(VK_FORMAT_D16_UNORM_S8_UINT, R16_UNORM, .cpp = 2, .num_channels = 2, .depth_format = D16_UNORM, .has_stencil = true), @@ -429,7 +429,7 @@ VkResult anv_GetPhysicalDeviceImageFormatProperties( } } - if (usage & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT) { + if (usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) { if (!(format_feature_flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) { goto unsupported; } diff --git a/src/vulkan/anv_image.c b/src/vulkan/anv_image.c index 014a9b9b342..e72c592905f 100644 --- a/src/vulkan/anv_image.c +++ b/src/vulkan/anv_image.c @@ -484,7 +484,7 @@ anv_image_view_init(struct anv_image_view *iview, assert(image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)); + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)); switch (image->type) { default: From c2f94e3a0d41c1f100f477498d3173ed1716eabc Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 11:43:13 -0700 Subject: [PATCH 74/76] vk/0.170.2: Update C++ errata and typedefs --- include/vulkan/vulkan.h | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 62305a60116..321a1d60b1b 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -55,7 +55,7 @@ extern "C" { #if defined(__cplusplus) - #if (_MSC_VER >= 1800 || __cplusplus >= 201103L) + #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L) // The bool operator only works if there are no implicit conversions from an obj to // a bool-compatible type, which can then be used to unintentionally violate type safety. // C++11 and above supports the "explicit" keyword on conversion operators to stop this @@ -63,13 +63,18 @@ extern "C" { // the object handle as a bool in expressions like: // if (obj) vkDestroy(obj); #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } + #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ + explicit obj(uint64_t x) : handle(x) { } \ + obj(decltype(nullptr)) : handle(0) { } #else #define VK_NONDISP_HANDLE_OPERATOR_BOOL() + #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ + obj(uint64_t x) : handle(x) { } #endif #define VK_DEFINE_NONDISP_HANDLE(obj) \ struct obj { \ obj() : handle(0) { } \ - obj(uint64_t x) : handle(x) { } \ + VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ obj& operator =(uint64_t x) { handle = x; return *this; } \ bool operator==(const obj& other) const { return handle == other.handle; } \ bool operator!=(const obj& other) const { return handle != other.handle; } \ @@ -83,6 +88,10 @@ extern "C" { +typedef uint32_t VkBool32; +typedef uint32_t VkFlags; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkSampleMask; VK_DEFINE_HANDLE(VkInstance) VK_DEFINE_HANDLE(VkPhysicalDevice) From 2f1ca713609d4c3d163788e4c49df6eef6401f7f Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 11:44:44 -0700 Subject: [PATCH 75/76] vk/0.170.2: Bump header version The header is now fully updated. --- include/vulkan/vulkan.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 321a1d60b1b..03bcefea50a 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -41,7 +41,7 @@ extern "C" { ((major << 22) | (minor << 12) | patch) // Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 138, 2) +#define VK_API_VERSION VK_MAKE_VERSION(0, 170, 2) #if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L) From 7fa98ab1828f40ecf98ca7239a032261bdfcf05f Mon Sep 17 00:00:00 2001 From: Chad Versace Date: Wed, 7 Oct 2015 11:45:48 -0700 Subject: [PATCH 76/76] vk: Remove temporary vulkan headers Remove vulkan-0.138.2.h and vulkan-0.170.2.h. Their purpose was to aid the header update to 0.170.2. --- include/vulkan/vulkan-0.138.2.h | 3054 ------------------------------- include/vulkan/vulkan-0.170.2.h | 3034 ------------------------------ 2 files changed, 6088 deletions(-) delete mode 100644 include/vulkan/vulkan-0.138.2.h delete mode 100644 include/vulkan/vulkan-0.170.2.h diff --git a/include/vulkan/vulkan-0.138.2.h b/include/vulkan/vulkan-0.138.2.h deleted file mode 100644 index 9877233bfeb..00000000000 --- a/include/vulkan/vulkan-0.138.2.h +++ /dev/null @@ -1,3054 +0,0 @@ -#ifndef __vulkan_h_ -#define __vulkan_h_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -/* -** 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) - -// Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 138, 2) - - -#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; - - -#if defined(__cplusplus) - #if (_MSC_VER >= 1800 || __cplusplus >= 201103L) - // The bool operator only works if there are no implicit conversions from an obj to - // a bool-compatible type, which can then be used to unintentionally violate type safety. - // C++11 and above supports the "explicit" keyword on conversion operators to stop this - // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating - // the object handle as a bool in expressions like: - // if (obj) vkDestroy(obj); - #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } - #else - #define VK_NONDISP_HANDLE_OPERATOR_BOOL() - #endif - #define VK_DEFINE_NONDISP_HANDLE(obj) \ - struct obj { \ - obj() : handle(0) { } \ - obj(uint64_t x) : handle(x) { } \ - obj& operator =(uint64_t x) { handle = x; return *this; } \ - bool operator==(const obj& other) const { return handle == other.handle; } \ - bool operator!=(const obj& other) const { return handle != other.handle; } \ - bool operator!() const { return !handle; } \ - VK_NONDISP_HANDLE_OPERATOR_BOOL() \ - uint64_t handle; \ - }; -#else - #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj; -#endif - - - -#define VK_LOD_CLAMP_NONE MAX_FLOAT -#define VK_LAST_MIP_LEVEL UINT32_MAX -#define VK_LAST_ARRAY_SLICE UINT32_MAX -#define VK_WHOLE_SIZE UINT64_MAX -#define VK_ATTACHMENT_UNUSED UINT32_MAX -#define VK_TRUE 1 -#define VK_FALSE 0 -#define VK_NULL_HANDLE 0 -#define VK_MAX_PHYSICAL_DEVICE_NAME 256 -#define VK_UUID_LENGTH 16 -#define VK_MAX_MEMORY_TYPES 32 -#define VK_MAX_MEMORY_HEAPS 16 -#define VK_MAX_EXTENSION_NAME 256 -#define VK_MAX_DESCRIPTION 256 - -VK_DEFINE_HANDLE(VkInstance) -VK_DEFINE_HANDLE(VkPhysicalDevice) -VK_DEFINE_HANDLE(VkDevice) -VK_DEFINE_HANDLE(VkQueue) -VK_DEFINE_HANDLE(VkCmdBuffer) -VK_DEFINE_NONDISP_HANDLE(VkFence) -VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory) -VK_DEFINE_NONDISP_HANDLE(VkBuffer) -VK_DEFINE_NONDISP_HANDLE(VkImage) -VK_DEFINE_NONDISP_HANDLE(VkSemaphore) -VK_DEFINE_NONDISP_HANDLE(VkEvent) -VK_DEFINE_NONDISP_HANDLE(VkQueryPool) -VK_DEFINE_NONDISP_HANDLE(VkBufferView) -VK_DEFINE_NONDISP_HANDLE(VkImageView) -VK_DEFINE_NONDISP_HANDLE(VkAttachmentView) -VK_DEFINE_NONDISP_HANDLE(VkShaderModule) -VK_DEFINE_NONDISP_HANDLE(VkShader) -VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) -VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout) -VK_DEFINE_NONDISP_HANDLE(VkRenderPass) -VK_DEFINE_NONDISP_HANDLE(VkPipeline) -VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) -VK_DEFINE_NONDISP_HANDLE(VkSampler) -VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) -VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) -VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) -VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) -VK_DEFINE_NONDISP_HANDLE(VkCmdPool) - - -typedef enum { - VK_SUCCESS = 0, - VK_UNSUPPORTED = 1, - VK_NOT_READY = 2, - VK_TIMEOUT = 3, - VK_EVENT_SET = 4, - VK_EVENT_RESET = 5, - VK_INCOMPLETE = 6, - VK_ERROR_UNKNOWN = -1, - VK_ERROR_UNAVAILABLE = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_OUT_OF_HOST_MEMORY = -4, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -5, - VK_ERROR_DEVICE_ALREADY_CREATED = -6, - VK_ERROR_DEVICE_LOST = -7, - VK_ERROR_INVALID_POINTER = -8, - VK_ERROR_INVALID_VALUE = -9, - VK_ERROR_INVALID_HANDLE = -10, - VK_ERROR_INVALID_ORDINAL = -11, - VK_ERROR_INVALID_MEMORY_SIZE = -12, - VK_ERROR_INVALID_EXTENSION = -13, - VK_ERROR_INVALID_FLAGS = -14, - VK_ERROR_INVALID_ALIGNMENT = -15, - VK_ERROR_INVALID_FORMAT = -16, - VK_ERROR_INVALID_IMAGE = -17, - VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18, - VK_ERROR_INVALID_QUEUE_TYPE = -19, - VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -20, - VK_ERROR_BAD_SHADER_CODE = -21, - VK_ERROR_BAD_PIPELINE_DATA = -22, - VK_ERROR_NOT_MAPPABLE = -23, - VK_ERROR_MEMORY_MAP_FAILED = -24, - VK_ERROR_MEMORY_UNMAP_FAILED = -25, - VK_ERROR_INCOMPATIBLE_DEVICE = -26, - VK_ERROR_INCOMPATIBLE_DRIVER = -27, - VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -28, - VK_ERROR_BUILDING_COMMAND_BUFFER = -29, - VK_ERROR_MEMORY_NOT_BOUND = -30, - VK_ERROR_INCOMPATIBLE_QUEUE = -31, - VK_ERROR_INVALID_LAYER = -32, - VK_RESULT_BEGIN_RANGE = VK_ERROR_INVALID_LAYER, - VK_RESULT_END_RANGE = VK_INCOMPLETE, - VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1), - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48, - VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49, - VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, - VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, - VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum { - VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, - VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, - VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, - VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, - VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, - VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), - VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocType; - -typedef enum { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM = 1, - VK_FORMAT_R4G4_USCALED = 2, - VK_FORMAT_R4G4B4A4_UNORM = 3, - VK_FORMAT_R4G4B4A4_USCALED = 4, - VK_FORMAT_R5G6B5_UNORM = 5, - VK_FORMAT_R5G6B5_USCALED = 6, - VK_FORMAT_R5G5B5A1_UNORM = 7, - VK_FORMAT_R5G5B5A1_USCALED = 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_R8G8B8A8_UNORM = 30, - VK_FORMAT_R8G8B8A8_SNORM = 31, - VK_FORMAT_R8G8B8A8_USCALED = 32, - VK_FORMAT_R8G8B8A8_SSCALED = 33, - VK_FORMAT_R8G8B8A8_UINT = 34, - VK_FORMAT_R8G8B8A8_SINT = 35, - VK_FORMAT_R8G8B8A8_SRGB = 36, - VK_FORMAT_R10G10B10A2_UNORM = 37, - VK_FORMAT_R10G10B10A2_SNORM = 38, - VK_FORMAT_R10G10B10A2_USCALED = 39, - VK_FORMAT_R10G10B10A2_SSCALED = 40, - VK_FORMAT_R10G10B10A2_UINT = 41, - VK_FORMAT_R10G10B10A2_SINT = 42, - VK_FORMAT_R16_UNORM = 43, - VK_FORMAT_R16_SNORM = 44, - VK_FORMAT_R16_USCALED = 45, - VK_FORMAT_R16_SSCALED = 46, - VK_FORMAT_R16_UINT = 47, - VK_FORMAT_R16_SINT = 48, - VK_FORMAT_R16_SFLOAT = 49, - VK_FORMAT_R16G16_UNORM = 50, - VK_FORMAT_R16G16_SNORM = 51, - VK_FORMAT_R16G16_USCALED = 52, - VK_FORMAT_R16G16_SSCALED = 53, - VK_FORMAT_R16G16_UINT = 54, - VK_FORMAT_R16G16_SINT = 55, - VK_FORMAT_R16G16_SFLOAT = 56, - VK_FORMAT_R16G16B16_UNORM = 57, - VK_FORMAT_R16G16B16_SNORM = 58, - VK_FORMAT_R16G16B16_USCALED = 59, - VK_FORMAT_R16G16B16_SSCALED = 60, - VK_FORMAT_R16G16B16_UINT = 61, - VK_FORMAT_R16G16B16_SINT = 62, - VK_FORMAT_R16G16B16_SFLOAT = 63, - VK_FORMAT_R16G16B16A16_UNORM = 64, - VK_FORMAT_R16G16B16A16_SNORM = 65, - VK_FORMAT_R16G16B16A16_USCALED = 66, - VK_FORMAT_R16G16B16A16_SSCALED = 67, - VK_FORMAT_R16G16B16A16_UINT = 68, - VK_FORMAT_R16G16B16A16_SINT = 69, - VK_FORMAT_R16G16B16A16_SFLOAT = 70, - VK_FORMAT_R32_UINT = 71, - VK_FORMAT_R32_SINT = 72, - VK_FORMAT_R32_SFLOAT = 73, - VK_FORMAT_R32G32_UINT = 74, - VK_FORMAT_R32G32_SINT = 75, - VK_FORMAT_R32G32_SFLOAT = 76, - VK_FORMAT_R32G32B32_UINT = 77, - VK_FORMAT_R32G32B32_SINT = 78, - VK_FORMAT_R32G32B32_SFLOAT = 79, - VK_FORMAT_R32G32B32A32_UINT = 80, - VK_FORMAT_R32G32B32A32_SINT = 81, - VK_FORMAT_R32G32B32A32_SFLOAT = 82, - VK_FORMAT_R64_SFLOAT = 83, - VK_FORMAT_R64G64_SFLOAT = 84, - VK_FORMAT_R64G64B64_SFLOAT = 85, - VK_FORMAT_R64G64B64A64_SFLOAT = 86, - VK_FORMAT_R11G11B10_UFLOAT = 87, - VK_FORMAT_R9G9B9E5_UFLOAT = 88, - VK_FORMAT_D16_UNORM = 89, - VK_FORMAT_D24_UNORM = 90, - VK_FORMAT_D32_SFLOAT = 91, - VK_FORMAT_S8_UINT = 92, - VK_FORMAT_D16_UNORM_S8_UINT = 93, - VK_FORMAT_D24_UNORM_S8_UINT = 94, - VK_FORMAT_D32_SFLOAT_S8_UINT = 95, - VK_FORMAT_BC1_RGB_UNORM = 96, - VK_FORMAT_BC1_RGB_SRGB = 97, - VK_FORMAT_BC1_RGBA_UNORM = 98, - VK_FORMAT_BC1_RGBA_SRGB = 99, - VK_FORMAT_BC2_UNORM = 100, - VK_FORMAT_BC2_SRGB = 101, - VK_FORMAT_BC3_UNORM = 102, - VK_FORMAT_BC3_SRGB = 103, - VK_FORMAT_BC4_UNORM = 104, - VK_FORMAT_BC4_SNORM = 105, - VK_FORMAT_BC5_UNORM = 106, - VK_FORMAT_BC5_SNORM = 107, - VK_FORMAT_BC6H_UFLOAT = 108, - VK_FORMAT_BC6H_SFLOAT = 109, - VK_FORMAT_BC7_UNORM = 110, - VK_FORMAT_BC7_SRGB = 111, - VK_FORMAT_ETC2_R8G8B8_UNORM = 112, - VK_FORMAT_ETC2_R8G8B8_SRGB = 113, - VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, - VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, - VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, - VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, - VK_FORMAT_EAC_R11_UNORM = 118, - VK_FORMAT_EAC_R11_SNORM = 119, - VK_FORMAT_EAC_R11G11_UNORM = 120, - VK_FORMAT_EAC_R11G11_SNORM = 121, - VK_FORMAT_ASTC_4x4_UNORM = 122, - VK_FORMAT_ASTC_4x4_SRGB = 123, - VK_FORMAT_ASTC_5x4_UNORM = 124, - VK_FORMAT_ASTC_5x4_SRGB = 125, - VK_FORMAT_ASTC_5x5_UNORM = 126, - VK_FORMAT_ASTC_5x5_SRGB = 127, - VK_FORMAT_ASTC_6x5_UNORM = 128, - VK_FORMAT_ASTC_6x5_SRGB = 129, - VK_FORMAT_ASTC_6x6_UNORM = 130, - VK_FORMAT_ASTC_6x6_SRGB = 131, - VK_FORMAT_ASTC_8x5_UNORM = 132, - VK_FORMAT_ASTC_8x5_SRGB = 133, - VK_FORMAT_ASTC_8x6_UNORM = 134, - VK_FORMAT_ASTC_8x6_SRGB = 135, - VK_FORMAT_ASTC_8x8_UNORM = 136, - VK_FORMAT_ASTC_8x8_SRGB = 137, - VK_FORMAT_ASTC_10x5_UNORM = 138, - VK_FORMAT_ASTC_10x5_SRGB = 139, - VK_FORMAT_ASTC_10x6_UNORM = 140, - VK_FORMAT_ASTC_10x6_SRGB = 141, - VK_FORMAT_ASTC_10x8_UNORM = 142, - VK_FORMAT_ASTC_10x8_SRGB = 143, - VK_FORMAT_ASTC_10x10_UNORM = 144, - VK_FORMAT_ASTC_10x10_SRGB = 145, - VK_FORMAT_ASTC_12x10_UNORM = 146, - VK_FORMAT_ASTC_12x10_SRGB = 147, - VK_FORMAT_ASTC_12x12_UNORM = 148, - VK_FORMAT_ASTC_12x12_SRGB = 149, - VK_FORMAT_B4G4R4A4_UNORM = 150, - VK_FORMAT_B5G5R5A1_UNORM = 151, - VK_FORMAT_B5G6R5_UNORM = 152, - VK_FORMAT_B5G6R5_USCALED = 153, - VK_FORMAT_B8G8R8_UNORM = 154, - VK_FORMAT_B8G8R8_SNORM = 155, - VK_FORMAT_B8G8R8_USCALED = 156, - VK_FORMAT_B8G8R8_SSCALED = 157, - VK_FORMAT_B8G8R8_UINT = 158, - VK_FORMAT_B8G8R8_SINT = 159, - VK_FORMAT_B8G8R8_SRGB = 160, - VK_FORMAT_B8G8R8A8_UNORM = 161, - VK_FORMAT_B8G8R8A8_SNORM = 162, - VK_FORMAT_B8G8R8A8_USCALED = 163, - VK_FORMAT_B8G8R8A8_SSCALED = 164, - VK_FORMAT_B8G8R8A8_UINT = 165, - VK_FORMAT_B8G8R8A8_SINT = 166, - VK_FORMAT_B8G8R8A8_SRGB = 167, - VK_FORMAT_B10G10R10A2_UNORM = 168, - VK_FORMAT_B10G10R10A2_SNORM = 169, - VK_FORMAT_B10G10R10A2_USCALED = 170, - VK_FORMAT_B10G10R10A2_SSCALED = 171, - VK_FORMAT_B10G10R10A2_UINT = 172, - VK_FORMAT_B10G10R10A2_SINT = 173, - VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, - VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, - VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum { - 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_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum { - VK_IMAGE_TILING_LINEAR = 0, - VK_IMAGE_TILING_OPTIMAL = 1, - VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, - VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum { - 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_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum { - VK_IMAGE_ASPECT_COLOR = 0, - VK_IMAGE_ASPECT_DEPTH = 1, - VK_IMAGE_ASPECT_STENCIL = 2, - VK_IMAGE_ASPECT_METADATA = 3, - VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, - VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA, - VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1), - VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF -} VkImageAspect; - -typedef enum { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, - VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, - VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum { - 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_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), - VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSharingMode; - -typedef enum { - VK_BUFFER_VIEW_TYPE_RAW = 0, - VK_BUFFER_VIEW_TYPE_FORMATTED = 1, - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW, - VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED, - VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1), - VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkBufferViewType; - -typedef enum { - 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_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum { - VK_CHANNEL_SWIZZLE_ZERO = 0, - VK_CHANNEL_SWIZZLE_ONE = 1, - VK_CHANNEL_SWIZZLE_R = 2, - VK_CHANNEL_SWIZZLE_G = 3, - VK_CHANNEL_SWIZZLE_B = 4, - VK_CHANNEL_SWIZZLE_A = 5, - VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, - VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, - VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), - VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkChannelSwizzle; - -typedef enum { - VK_SHADER_STAGE_VERTEX = 0, - VK_SHADER_STAGE_TESS_CONTROL = 1, - VK_SHADER_STAGE_TESS_EVALUATION = 2, - VK_SHADER_STAGE_GEOMETRY = 3, - VK_SHADER_STAGE_FRAGMENT = 4, - VK_SHADER_STAGE_COMPUTE = 5, - VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, - VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, - VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), - VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF -} VkShaderStage; - -typedef enum { - VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, - VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, - VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, - VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), - VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputStepRate; - -typedef enum { - 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_ADJ = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH = 10, - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, - VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum { - VK_FILL_MODE_POINTS = 0, - VK_FILL_MODE_WIREFRAME = 1, - VK_FILL_MODE_SOLID = 2, - VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, - VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, - VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), - VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF -} VkFillMode; - -typedef enum { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT = 1, - VK_CULL_MODE_BACK = 2, - VK_CULL_MODE_FRONT_AND_BACK = 3, - VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, - VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, - VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), - VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF -} VkCullMode; - -typedef enum { - VK_FRONT_FACE_CCW = 0, - VK_FRONT_FACE_CW = 1, - VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, - VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, - VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_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_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INC_CLAMP = 3, - VK_STENCIL_OP_DEC_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INC_WRAP = 6, - VK_STENCIL_OP_DEC_WRAP = 7, - VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, - VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, - VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum { - 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_NOOP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIV = 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_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum { - VK_BLEND_ZERO = 0, - VK_BLEND_ONE = 1, - VK_BLEND_SRC_COLOR = 2, - VK_BLEND_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_DEST_COLOR = 4, - VK_BLEND_ONE_MINUS_DEST_COLOR = 5, - VK_BLEND_SRC_ALPHA = 6, - VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_DEST_ALPHA = 8, - VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, - VK_BLEND_CONSTANT_COLOR = 10, - VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_CONSTANT_ALPHA = 12, - VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_SRC_ALPHA_SATURATE = 14, - VK_BLEND_SRC1_COLOR = 15, - VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_SRC1_ALPHA = 17, - VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, - VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, - VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), - VK_BLEND_MAX_ENUM = 0x7FFFFFFF -} VkBlend; - -typedef enum { - 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_BEGIN_RANGE = VK_BLEND_OP_ADD, - VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, - VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum { - VK_TEX_FILTER_NEAREST = 0, - VK_TEX_FILTER_LINEAR = 1, - VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, - VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, - VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), - VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkTexFilter; - -typedef enum { - VK_TEX_MIPMAP_MODE_BASE = 0, - VK_TEX_MIPMAP_MODE_NEAREST = 1, - VK_TEX_MIPMAP_MODE_LINEAR = 2, - VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, - VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, - VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), - VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkTexMipmapMode; - -typedef enum { - VK_TEX_ADDRESS_WRAP = 0, - VK_TEX_ADDRESS_MIRROR = 1, - VK_TEX_ADDRESS_CLAMP = 2, - VK_TEX_ADDRESS_MIRROR_ONCE = 3, - VK_TEX_ADDRESS_CLAMP_BORDER = 4, - VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, - VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, - VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1), - VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF -} VkTexAddress; - -typedef enum { - 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_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum { - 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_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, - VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, - VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum { - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, - VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, - VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, - VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), - VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolUsage; - -typedef enum { - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, - VK_DESCRIPTOR_SET_USAGE_STATIC = 1, - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, - VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, - VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), - VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetUsage; - -typedef enum { - 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_SOURCE_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, - VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, - VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum { - 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_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum { - 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_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum { - VK_PIPELINE_BIND_POINT_COMPUTE = 0, - VK_PIPELINE_BIND_POINT_GRAPHICS = 1, - VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, - VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, - VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum { - VK_CMD_BUFFER_LEVEL_PRIMARY = 0, - VK_CMD_BUFFER_LEVEL_SECONDARY = 1, - VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, - VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, - VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), - VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCmdBufferLevel; - -typedef enum { - 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_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum { - VK_TIMESTAMP_TYPE_TOP = 0, - VK_TIMESTAMP_TYPE_BOTTOM = 1, - VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, - VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, - VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), - VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkTimestampType; - -typedef enum { - VK_RENDER_PASS_CONTENTS_INLINE = 0, - VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, - VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, - VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, - VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), - VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassContents; - - -typedef enum { - 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_CONVERSION_BIT = 0x00000400, -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum { - VK_IMAGE_USAGE_GENERAL = 0, - VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DESTINATION_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_BIT = 0x00000020, - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; - -typedef enum { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_DMA_BIT = 0x00000004, - VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, - VK_QUEUE_EXTENDED_BIT = 0x40000000, -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; - -typedef enum { - VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum { - VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; - -typedef enum { - VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, -} VkDeviceCreateFlagBits; -typedef VkFlags VkDeviceCreateFlags; -typedef VkFlags VkMemoryMapFlags; - -typedef enum { - VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, - VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, - VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, -} VkSparseImageFormatFlagBits; -typedef VkFlags VkSparseImageFormatFlags; - -typedef enum { - VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, -} VkSparseMemoryBindFlagBits; -typedef VkFlags VkSparseMemoryBindFlags; - -typedef enum { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; -typedef VkFlags VkEventCreateFlags; - -typedef enum { - VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; - -typedef enum { - VK_QUERY_RESULT_DEFAULT = 0, - 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, -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum { - VK_BUFFER_USAGE_GENERAL = 0, - VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DESTINATION_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, -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; - -typedef enum { - VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum { - VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum { - VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, - VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, -} VkAttachmentViewCreateFlagBits; -typedef VkFlags VkAttachmentViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; -typedef VkFlags VkShaderCreateFlags; - -typedef enum { - VK_CHANNEL_R_BIT = 0x00000001, - VK_CHANNEL_G_BIT = 0x00000002, - VK_CHANNEL_B_BIT = 0x00000004, - VK_CHANNEL_A_BIT = 0x00000008, -} VkChannelFlagBits; -typedef VkFlags VkChannelFlags; - -typedef enum { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; - -typedef enum { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESS_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 = 0x7FFFFFFF, -} VkShaderStageFlagBits; -typedef VkFlags VkShaderStageFlags; - -typedef enum { - VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, -} VkSubpassDescriptionFlagBits; -typedef VkFlags VkSubpassDescriptionFlags; - -typedef enum { - 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_TESS_CONTROL_SHADER_BIT = 0x00000010, - VK_PIPELINE_STAGE_TESS_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_TRANSITION_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, - VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, - VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF, -} VkPipelineStageFlagBits; -typedef VkFlags VkPipelineStageFlags; - -typedef enum { - VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, - VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, - VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, - VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, - VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, -} VkMemoryOutputFlagBits; -typedef VkFlags VkMemoryOutputFlags; - -typedef enum { - VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, - VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, - VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, - VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, - VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, - VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, - VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, - VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, - VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, - VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, -} VkMemoryInputFlagBits; -typedef VkFlags VkMemoryInputFlags; - -typedef enum { - VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, -} VkCmdPoolCreateFlagBits; -typedef VkFlags VkCmdPoolCreateFlags; - -typedef enum { - VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001, -} VkCmdPoolResetFlagBits; -typedef VkFlags VkCmdPoolResetFlags; -typedef VkFlags VkCmdBufferCreateFlags; - -typedef enum { - VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, - VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, - VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, - VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, - VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, -} VkCmdBufferOptimizeFlagBits; -typedef VkFlags VkCmdBufferOptimizeFlags; - -typedef enum { - VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001, -} VkCmdBufferResetFlagBits; -typedef VkFlags VkCmdBufferResetFlags; - -typedef enum { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum { - VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef struct { - VkStructureType sType; - const void* pNext; - const char* pAppName; - uint32_t appVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef void* (VKAPI *PFN_vkAllocFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocType allocType); - -typedef void (VKAPI *PFN_vkFreeFunction)( - void* pUserData, - void* pMem); - -typedef struct { - void* pUserData; - PFN_vkAllocFunction pfnAlloc; - PFN_vkFreeFunction pfnFree; -} VkAllocCallbacks; - -typedef struct { - VkStructureType sType; - const void* pNext; - const VkApplicationInfo* pAppInfo; - const VkAllocCallbacks* pAllocCb; - uint32_t layerCount; - const char*const* ppEnabledLayerNames; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef struct { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSourceBlend; - VkBool32 logicOp; - VkBool32 instancedDrawIndirect; - VkBool32 depthClip; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexSideEffects; - VkBool32 tessellationSideEffects; - VkBool32 geometrySideEffects; - VkBool32 fragmentSideEffects; - VkBool32 shaderTessellationPointSize; - VkBool32 shaderGeometryPointSize; - VkBool32 shaderTextureGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageBufferArrayConstantIndexing; - VkBool32 shaderStorageImageArrayConstantIndexing; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderFloat16; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLOD; - VkBool32 sparse; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyStandard2DBlockShape; - VkBool32 sparseResidencyStandard2DMSBlockShape; - VkBool32 sparseResidencyStandard3DBlockShape; - VkBool32 sparseResidencyAlignedMipSize; - VkBool32 sparseResidencyNonResident; - VkBool32 sparseResidencyNonResidentStrict; - VkBool32 sparseResidencyAliased; -} VkPhysicalDeviceFeatures; - -typedef struct { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; -} VkFormatProperties; - -typedef struct { - uint64_t maxResourceSize; - uint32_t maxSamples; -} VkImageFormatProperties; - -typedef struct { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferSize; - uint32_t maxUniformBufferSize; - uint32_t maxStorageBufferSize; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - VkDeviceSize bufferImageGranularity; - uint32_t maxBoundDescriptorSets; - uint32_t maxDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessGenLevel; - uint32_t maxTessPatchSize; - uint32_t maxTessControlPerVertexInputComponents; - uint32_t maxTessControlPerVertexOutputComponents; - uint32_t maxTessControlPerPatchOutputComponents; - uint32_t maxTessControlTotalOutputComponents; - uint32_t maxTessEvaluationInputComponents; - uint32_t maxTessEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputBuffers; - uint32_t maxFragmentDualSourceBuffers; - 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 maxDrawIndirectInstanceCount; - VkBool32 primitiveRestartForPatches; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxDynamicViewportStates; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - uint32_t minMemoryMapAlignment; - uint32_t minTexelBufferOffsetAlignment; - uint32_t minUniformBufferOffsetAlignment; - uint32_t minStorageBufferOffsetAlignment; - uint32_t minTexelOffset; - uint32_t maxTexelOffset; - uint32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - uint32_t maxFramebufferColorSamples; - uint32_t maxFramebufferDepthSamples; - uint32_t maxFramebufferStencilSamples; - uint32_t maxColorAttachments; - uint32_t maxSampledImageColorSamples; - uint32_t maxSampledImageDepthSamples; - uint32_t maxSampledImageIntegerSamples; - uint32_t maxStorageImageSamples; - uint32_t maxSampleMaskWords; - uint64_t timestampFrequency; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; -} VkPhysicalDeviceLimits; - -typedef struct { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; - uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; -} VkPhysicalDeviceProperties; - -typedef struct { - VkQueueFlags queueFlags; - uint32_t queueCount; - VkBool32 supportsTimestamps; -} VkPhysicalDeviceQueueProperties; - -typedef struct { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; - -typedef void (VKAPI *PFN_vkVoidFunction)(void); -typedef struct { - uint32_t queueFamilyIndex; - uint32_t queueCount; -} VkDeviceQueueCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueRecordCount; - const VkDeviceQueueCreateInfo* pRequestedQueues; - uint32_t layerCount; - const char*const* ppEnabledLayerNames; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; - VkDeviceCreateFlags flags; -} VkDeviceCreateInfo; - -typedef struct { - char extName[VK_MAX_EXTENSION_NAME]; - uint32_t specVersion; -} VkExtensionProperties; - -typedef struct { - char layerName[VK_MAX_EXTENSION_NAME]; - uint32_t specVersion; - uint32_t implVersion; - char description[VK_MAX_DESCRIPTION]; -} VkLayerProperties; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceMemory mem; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct { - VkDeviceSize size; - VkDeviceSize alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct { - int32_t width; - int32_t height; - int32_t depth; -} VkExtent3D; - -typedef struct { - VkImageAspect aspect; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; - -typedef struct { - VkSparseImageFormatProperties formatProps; - uint32_t imageMipTailStartLOD; - VkDeviceSize imageMipTailSize; - VkDeviceSize imageMipTailOffset; - VkDeviceSize imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct { - VkDeviceSize rangeOffset; - VkDeviceSize rangeSize; - VkDeviceSize memOffset; - VkDeviceMemory mem; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBindInfo; - -typedef struct { - VkImageAspect aspect; - uint32_t mipLevel; - uint32_t arraySlice; -} VkImageSubresource; - -typedef struct { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceSize memOffset; - VkDeviceMemory mem; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBindInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkQueryType queryType; - uint32_t slots; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkBufferCreateFlags flags; - VkSharingMode sharingMode; - uint32_t queueFamilyCount; - const uint32_t* pQueueFamilyIndices; -} VkBufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkBufferViewType viewType; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; - VkSharingMode sharingMode; - uint32_t queueFamilyCount; - const uint32_t* pQueueFamilyIndices; -} VkImageCreateInfo; - -typedef struct { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct { - VkChannelSwizzle r; - VkChannelSwizzle g; - VkChannelSwizzle b; - VkChannelSwizzle a; -} VkChannelMapping; - -typedef struct { - VkImageAspect aspect; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArraySlice; - uint32_t arraySize; -} VkImageSubresourceRange; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkChannelMapping channels; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - VkFormat format; - uint32_t mipLevel; - uint32_t baseArraySlice; - uint32_t arraySize; - VkAttachmentViewCreateFlags flags; -} VkAttachmentViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - size_t codeSize; - const void* pCode; - VkShaderModuleCreateFlags flags; -} VkShaderModuleCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkShaderModule module; - const char* pName; - VkShaderCreateFlags flags; -} VkShaderCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - size_t initialSize; - const void* initialData; - size_t maxSize; -} VkPipelineCacheCreateInfo; - -typedef struct { - uint32_t constantId; - size_t size; - uint32_t offset; -} VkSpecializationMapEntry; - -typedef struct { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMap; - size_t dataSize; - const void* pData; -} VkSpecializationInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkShaderStage stage; - VkShader shader; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct { - uint32_t binding; - uint32_t strideInBytes; - VkVertexInputStepRate stepRate; -} VkVertexInputBindingDescription; - -typedef struct { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offsetInBytes; -} VkVertexInputAttributeDescription; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t attributeCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportCount; -} VkPipelineViewportStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBool32 depthClipEnable; - VkBool32 rasterizerDiscardEnable; - VkFillMode fillMode; - VkCullMode cullMode; - VkFrontFace frontFace; -} VkPipelineRasterStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t rasterSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - VkSampleMask sampleMask; -} VkPipelineMultisampleStateCreateInfo; - -typedef struct { - VkStencilOp stencilFailOp; - VkStencilOp stencilPassOp; - VkStencilOp stencilDepthFailOp; - VkCompareOp stencilCompareOp; -} VkStencilOpState; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct { - VkBool32 blendEnable; - VkBlend srcBlendColor; - VkBlend destBlendColor; - VkBlendOp blendOpColor; - VkBlend srcBlendAlpha; - VkBlend destBlendAlpha; - VkBlendOp blendOpAlpha; - VkChannelFlags channelWriteMask; -} VkPipelineColorBlendAttachmentState; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBool32 alphaToCoverageEnable; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState* pAttachments; -} VkPipelineColorBlendStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; - const VkPipelineViewportStateCreateInfo* pViewportState; - const VkPipelineRasterStateCreateInfo* pRasterState; - const VkPipelineMultisampleStateCreateInfo* pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo* pColorBlendState; - VkPipelineCreateFlags flags; - VkPipelineLayout layout; - VkRenderPass renderPass; - uint32_t subpass; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateInfo cs; - VkPipelineCreateFlags flags; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct { - VkShaderStageFlags stageFlags; - uint32_t start; - uint32_t length; -} VkPushConstantRange; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkTexFilter magFilter; - VkTexFilter minFilter; - VkTexMipmapMode mipMode; - VkTexAddress addressU; - VkTexAddress addressV; - VkTexAddress addressW; - float mipLodBias; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; -} VkSamplerCreateInfo; - -typedef struct { - VkDescriptorType descriptorType; - uint32_t arraySize; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t count; - const VkDescriptorSetLayoutBinding* pBinding; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct { - VkDescriptorType type; - uint32_t count; -} VkDescriptorTypeCount; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t count; - const VkDescriptorTypeCount* pTypeCount; -} VkDescriptorPoolCreateInfo; - -typedef struct { - VkBufferView bufferView; - VkSampler sampler; - VkImageView imageView; - VkAttachmentView attachmentView; - VkImageLayout imageLayout; -} VkDescriptorInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorSet destSet; - uint32_t destBinding; - uint32_t destArrayElement; - uint32_t count; - VkDescriptorType descriptorType; - const VkDescriptorInfo* pDescriptors; -} VkWriteDescriptorSet; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet destSet; - uint32_t destBinding; - uint32_t destArrayElement; - uint32_t count; -} VkCopyDescriptorSet; - -typedef struct { - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct { - int32_t width; - int32_t height; -} VkExtent2D; - -typedef struct { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportAndScissorCount; - const VkViewport* pViewports; - const VkRect2D* pScissors; -} VkDynamicViewportStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float lineWidth; -} VkDynamicRasterStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float blendConst[4]; -} VkDynamicColorBlendStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float minDepthBounds; - float maxDepthBounds; - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VkDynamicDepthStencilStateCreateInfo; - -typedef struct { - VkAttachmentView view; - VkImageLayout layout; -} VkAttachmentBindInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t attachmentCount; - const VkAttachmentBindInfo* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkFormat format; - uint32_t samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; - -typedef struct { - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkSubpassDescriptionFlags flags; - uint32_t inputCount; - const VkAttachmentReference* inputAttachments; - uint32_t colorCount; - const VkAttachmentReference* colorAttachments; - const VkAttachmentReference* resolveAttachments; - VkAttachmentReference depthStencilAttachment; - uint32_t preserveCount; - const VkAttachmentReference* preserveAttachments; -} VkSubpassDescription; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t srcSubpass; - uint32_t destSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags destStageMask; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - VkBool32 byRegion; -} VkSubpassDependency; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkAttachmentDescription* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency* pDependencies; -} VkRenderPassCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - VkCmdPoolCreateFlags flags; -} VkCmdPoolCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkCmdPool cmdPool; - VkCmdBufferLevel level; - VkCmdBufferCreateFlags flags; -} VkCmdBufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkCmdBufferOptimizeFlags flags; - VkRenderPass renderPass; - VkFramebuffer framebuffer; -} VkCmdBufferBeginInfo; - -typedef struct { - VkDeviceSize srcOffset; - VkDeviceSize destOffset; - VkDeviceSize copySize; -} VkBufferCopy; - -typedef struct { - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct { - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkExtent3D srcExtent; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D destExtent; -} VkImageBlit; - -typedef struct { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresource imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef union { - float f32[4]; - int32_t s32[4]; - uint32_t u32[4]; -} VkClearColorValue; - -typedef struct { - VkOffset3D offset; - VkExtent3D extent; -} VkRect3D; - -typedef struct { - VkImageSubresource srcSubresource; - VkOffset3D srcOffset; - VkImageSubresource destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - -typedef union { - VkClearColorValue color; - VkClearDepthStencilValue ds; -} VkClearValue; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRect2D renderArea; - uint32_t attachmentCount; - const VkClearValue* pAttachmentClearValues; -} VkRenderPassBeginInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - uint32_t srcQueueFamilyIndex; - uint32_t destQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCmd; - -typedef struct { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCmd; - -typedef struct { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCmd; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t destQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; -} VkMemoryBarrier; - - -typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); -typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); -typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); -typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); -typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); -typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); -typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); -typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); -typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); -typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); -typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); -typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); -typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); -typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); -typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); -typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); -typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); -typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); -typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); -typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); -typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); -typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView); -typedef VkResult (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView); -typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); -typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); -typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); -typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); -typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); -typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); -typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); -typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); -typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); -typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); -typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); -typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); -typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); -typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); -typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); -typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); -typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); -typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); -typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); -typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); -typedef VkResult (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); -typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); -typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); -typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); -typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); -typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); -typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); -typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState); -typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState); -typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState); -typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); -typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); -typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); -typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); -typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); -typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); -typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); -typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); -typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); -typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); -typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents); -typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); -typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); - -#ifdef VK_PROTOTYPES -VkResult VKAPI vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - VkInstance* pInstance); - -VkResult VKAPI vkDestroyInstance( - VkInstance instance); - -VkResult VKAPI vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VkResult VKAPI vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); - -VkResult VKAPI vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties); - -VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageFormatProperties* pImageFormatProperties); - -VkResult VKAPI vkGetPhysicalDeviceLimits( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceLimits* pLimits); - -VkResult VKAPI vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); - -VkResult VKAPI vkGetPhysicalDeviceQueueCount( - VkPhysicalDevice physicalDevice, - uint32_t* pCount); - -VkResult VKAPI vkGetPhysicalDeviceQueueProperties( - VkPhysicalDevice physicalDevice, - uint32_t count, - VkPhysicalDeviceQueueProperties* pQueueProperties); - -VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties); - -PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( - VkInstance instance, - const char* pName); - -PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( - VkDevice device, - const char* pName); - -VkResult VKAPI vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - VkDevice* pDevice); - -VkResult VKAPI vkDestroyDevice( - VkDevice device); - -VkResult VKAPI vkGetGlobalExtensionProperties( - const char* pLayerName, - uint32_t* pCount, - VkExtensionProperties* pProperties); - -VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pCount, - VkExtensionProperties* pProperties); - -VkResult VKAPI vkGetGlobalLayerProperties( - uint32_t* pCount, - VkLayerProperties* pProperties); - -VkResult VKAPI vkGetPhysicalDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pCount, - VkLayerProperties* pProperties); - -VkResult VKAPI vkGetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VkResult VKAPI vkQueueSubmit( - VkQueue queue, - uint32_t cmdBufferCount, - const VkCmdBuffer* pCmdBuffers, - VkFence fence); - -VkResult VKAPI vkQueueWaitIdle( - VkQueue queue); - -VkResult VKAPI vkDeviceWaitIdle( - VkDevice device); - -VkResult VKAPI vkAllocMemory( - VkDevice device, - const VkMemoryAllocInfo* pAllocInfo, - VkDeviceMemory* pMem); - -VkResult VKAPI vkFreeMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkMapMemory( - VkDevice device, - VkDeviceMemory mem, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -VkResult VKAPI vkUnmapMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkFlushMappedMemoryRanges( - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); - -VkResult VKAPI vkInvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); - -VkResult VKAPI vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); - -VkResult VKAPI vkBindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkBindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkGetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); - -VkResult VKAPI vkGetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); - -VkResult VKAPI vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pNumRequirements, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); - -VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - uint32_t samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pNumProperties, - VkSparseImageFormatProperties* pProperties); - -VkResult VKAPI vkQueueBindSparseBufferMemory( - VkQueue queue, - VkBuffer buffer, - uint32_t numBindings, - const VkSparseMemoryBindInfo* pBindInfo); - -VkResult VKAPI vkQueueBindSparseImageOpaqueMemory( - VkQueue queue, - VkImage image, - uint32_t numBindings, - const VkSparseMemoryBindInfo* pBindInfo); - -VkResult VKAPI vkQueueBindSparseImageMemory( - VkQueue queue, - VkImage image, - uint32_t numBindings, - const VkSparseImageMemoryBindInfo* pBindInfo); - -VkResult VKAPI vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - VkFence* pFence); - -VkResult VKAPI vkDestroyFence( - VkDevice device, - VkFence fence); - -VkResult VKAPI vkResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); - -VkResult VKAPI vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VkResult VKAPI vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); - -VkResult VKAPI vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - VkSemaphore* pSemaphore); - -VkResult VKAPI vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore); - -VkResult VKAPI vkQueueSignalSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkQueueWaitSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - VkEvent* pEvent); - -VkResult VKAPI vkDestroyEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkGetEventStatus( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkSetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkResetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - VkQueryPool* pQueryPool); - -VkResult VKAPI vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool); - -VkResult VKAPI vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData, - VkQueryResultFlags flags); - -VkResult VKAPI vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - VkBuffer* pBuffer); - -VkResult VKAPI vkDestroyBuffer( - VkDevice device, - VkBuffer buffer); - -VkResult VKAPI vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - VkBufferView* pView); - -VkResult VKAPI vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView); - -VkResult VKAPI vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - VkImage* pImage); - -VkResult VKAPI vkDestroyImage( - VkDevice device, - VkImage image); - -VkResult VKAPI vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); - -VkResult VKAPI vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - VkImageView* pView); - -VkResult VKAPI vkDestroyImageView( - VkDevice device, - VkImageView imageView); - -VkResult VKAPI vkCreateAttachmentView( - VkDevice device, - const VkAttachmentViewCreateInfo* pCreateInfo, - VkAttachmentView* pView); - -VkResult VKAPI vkDestroyAttachmentView( - VkDevice device, - VkAttachmentView attachmentView); - -VkResult VKAPI vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModule* pShaderModule); - -VkResult VKAPI vkDestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule); - -VkResult VKAPI vkCreateShader( - VkDevice device, - const VkShaderCreateInfo* pCreateInfo, - VkShader* pShader); - -VkResult VKAPI vkDestroyShader( - VkDevice device, - VkShader shader); - -VkResult VKAPI vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - VkPipelineCache* pPipelineCache); - -VkResult VKAPI vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache); - -size_t VKAPI vkGetPipelineCacheSize( - VkDevice device, - VkPipelineCache pipelineCache); - -VkResult VKAPI vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - void* pData); - -VkResult VKAPI vkMergePipelineCaches( - VkDevice device, - VkPipelineCache destCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); - -VkResult VKAPI vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - -VkResult VKAPI vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkComputePipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - -VkResult VKAPI vkDestroyPipeline( - VkDevice device, - VkPipeline pipeline); - -VkResult VKAPI vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - VkPipelineLayout* pPipelineLayout); - -VkResult VKAPI vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout); - -VkResult VKAPI vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - VkSampler* pSampler); - -VkResult VKAPI vkDestroySampler( - VkDevice device, - VkSampler sampler); - -VkResult VKAPI vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout); - -VkResult VKAPI vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout); - -VkResult VKAPI vkCreateDescriptorPool( - VkDevice device, - VkDescriptorPoolUsage poolUsage, - uint32_t maxSets, - const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool); - -VkResult VKAPI vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool); - -VkResult VKAPI vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool); - -VkResult VKAPI vkAllocDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorSetUsage setUsage, - uint32_t count, - const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets, - uint32_t* pCount); - -VkResult VKAPI vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t count, - const VkDescriptorSet* pDescriptorSets); - -VkResult VKAPI vkUpdateDescriptorSets( - VkDevice device, - uint32_t writeCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t copyCount, - const VkCopyDescriptorSet* pDescriptorCopies); - -VkResult VKAPI vkCreateDynamicViewportState( - VkDevice device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState); - -VkResult VKAPI vkDestroyDynamicViewportState( - VkDevice device, - VkDynamicViewportState dynamicViewportState); - -VkResult VKAPI vkCreateDynamicRasterState( - VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState); - -VkResult VKAPI vkDestroyDynamicRasterState( - VkDevice device, - VkDynamicRasterState dynamicRasterState); - -VkResult VKAPI vkCreateDynamicColorBlendState( - VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState); - -VkResult VKAPI vkDestroyDynamicColorBlendState( - VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState); - -VkResult VKAPI vkCreateDynamicDepthStencilState( - VkDevice device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState); - -VkResult VKAPI vkDestroyDynamicDepthStencilState( - VkDevice device, - VkDynamicDepthStencilState dynamicDepthStencilState); - -VkResult VKAPI vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - VkFramebuffer* pFramebuffer); - -VkResult VKAPI vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer); - -VkResult VKAPI vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass); - -VkResult VKAPI vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass); - -VkResult VKAPI vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); - -VkResult VKAPI vkCreateCommandPool( - VkDevice device, - const VkCmdPoolCreateInfo* pCreateInfo, - VkCmdPool* pCmdPool); - -VkResult VKAPI vkDestroyCommandPool( - VkDevice device, - VkCmdPool cmdPool); - -VkResult VKAPI vkResetCommandPool( - VkDevice device, - VkCmdPool cmdPool, - VkCmdPoolResetFlags flags); - -VkResult VKAPI vkCreateCommandBuffer( - VkDevice device, - const VkCmdBufferCreateInfo* pCreateInfo, - VkCmdBuffer* pCmdBuffer); - -VkResult VKAPI vkDestroyCommandBuffer( - VkDevice device, - VkCmdBuffer commandBuffer); - -VkResult VKAPI vkBeginCommandBuffer( - VkCmdBuffer cmdBuffer, - const VkCmdBufferBeginInfo* pBeginInfo); - -VkResult VKAPI vkEndCommandBuffer( - VkCmdBuffer cmdBuffer); - -VkResult VKAPI vkResetCommandBuffer( - VkCmdBuffer cmdBuffer, - VkCmdBufferResetFlags flags); - -void VKAPI vkCmdBindPipeline( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -void VKAPI vkCmdBindDynamicViewportState( - VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState); - -void VKAPI vkCmdBindDynamicRasterState( - VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState); - -void VKAPI vkCmdBindDynamicColorBlendState( - VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState); - -void VKAPI vkCmdBindDynamicDepthStencilState( - VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState); - -void VKAPI vkCmdBindDescriptorSets( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -void VKAPI vkCmdBindIndexBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -void VKAPI vkCmdBindVertexBuffers( - VkCmdBuffer cmdBuffer, - uint32_t startBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -void VKAPI vkCmdDraw( - VkCmdBuffer cmdBuffer, - uint32_t firstVertex, - uint32_t vertexCount, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndexed( - VkCmdBuffer cmdBuffer, - uint32_t firstIndex, - uint32_t indexCount, - int32_t vertexOffset, - uint32_t firstInstance, - uint32_t instanceCount); - -void VKAPI vkCmdDrawIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDrawIndexedIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDispatch( - VkCmdBuffer cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); - -void VKAPI vkCmdDispatchIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -void VKAPI vkCmdCopyBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -void VKAPI vkCmdCopyImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -void VKAPI vkCmdBlitImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkTexFilter filter); - -void VKAPI vkCmdCopyBufferToImage( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdCopyImageToBuffer( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdUpdateBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize dataSize, - const uint32_t* pData); - -void VKAPI vkCmdFillBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize fillSize, - uint32_t data); - -void VKAPI vkCmdClearColorImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearDepthStencilImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - float depth, - uint32_t stencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearColorAttachment( - VkCmdBuffer cmdBuffer, - uint32_t colorAttachment, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rectCount, - const VkRect3D* pRects); - -void VKAPI vkCmdClearDepthStencilAttachment( - VkCmdBuffer cmdBuffer, - VkImageAspectFlags imageAspectMask, - VkImageLayout imageLayout, - float depth, - uint32_t stencil, - uint32_t rectCount, - const VkRect3D* pRects); - -void VKAPI vkCmdResolveImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -void VKAPI vkCmdSetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -void VKAPI vkCmdResetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -void VKAPI vkCmdWaitEvents( - VkCmdBuffer cmdBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - -void VKAPI vkCmdPipelineBarrier( - VkCmdBuffer cmdBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - VkBool32 byRegion, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - -void VKAPI vkCmdBeginQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot, - VkQueryControlFlags flags); - -void VKAPI vkCmdEndQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot); - -void VKAPI vkCmdResetQueryPool( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount); - -void VKAPI vkCmdWriteTimestamp( - VkCmdBuffer cmdBuffer, - VkTimestampType timestampType, - VkBuffer destBuffer, - VkDeviceSize destOffset); - -void VKAPI vkCmdCopyQueryPoolResults( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize destStride, - VkQueryResultFlags flags); - -void VKAPI vkCmdPushConstants( - VkCmdBuffer cmdBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t start, - uint32_t length, - const void* values); - -void VKAPI vkCmdBeginRenderPass( - VkCmdBuffer cmdBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkRenderPassContents contents); - -void VKAPI vkCmdNextSubpass( - VkCmdBuffer cmdBuffer, - VkRenderPassContents contents); - -void VKAPI vkCmdEndRenderPass( - VkCmdBuffer cmdBuffer); - -void VKAPI vkCmdExecuteCommands( - VkCmdBuffer cmdBuffer, - uint32_t cmdBuffersCount, - const VkCmdBuffer* pCmdBuffers); -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/vulkan/vulkan-0.170.2.h b/include/vulkan/vulkan-0.170.2.h deleted file mode 100644 index 03bcefea50a..00000000000 --- a/include/vulkan/vulkan-0.170.2.h +++ /dev/null @@ -1,3034 +0,0 @@ -#ifndef __vulkan_h_ -#define __vulkan_h_ 1 - -#ifdef __cplusplus -extern "C" { -#endif - -/* -** Copyright (c) 2015 The Khronos Group Inc. -** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: -** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -*/ - -/* -** 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) - -// Vulkan API version supported by this file -#define VK_API_VERSION VK_MAKE_VERSION(0, 170, 2) - - -#if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L) - #define VK_NULL_HANDLE nullptr -#else - #define VK_NULL_HANDLE 0 -#endif - - -#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; - - -#if defined(__cplusplus) - #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L) - // The bool operator only works if there are no implicit conversions from an obj to - // a bool-compatible type, which can then be used to unintentionally violate type safety. - // C++11 and above supports the "explicit" keyword on conversion operators to stop this - // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating - // the object handle as a bool in expressions like: - // if (obj) vkDestroy(obj); - #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } - #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ - explicit obj(uint64_t x) : handle(x) { } \ - obj(decltype(nullptr)) : handle(0) { } - #else - #define VK_NONDISP_HANDLE_OPERATOR_BOOL() - #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ - obj(uint64_t x) : handle(x) { } - #endif - #define VK_DEFINE_NONDISP_HANDLE(obj) \ - struct obj { \ - obj() : handle(0) { } \ - VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \ - obj& operator =(uint64_t x) { handle = x; return *this; } \ - bool operator==(const obj& other) const { return handle == other.handle; } \ - bool operator!=(const obj& other) const { return handle != other.handle; } \ - bool operator!() const { return !handle; } \ - VK_NONDISP_HANDLE_OPERATOR_BOOL() \ - uint64_t handle; \ - }; -#else - #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj; -#endif - - - -typedef uint32_t VkBool32; -typedef uint32_t VkFlags; -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_HANDLE(VkCmdBuffer) -VK_DEFINE_NONDISP_HANDLE(VkFence) -VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory) -VK_DEFINE_NONDISP_HANDLE(VkBuffer) -VK_DEFINE_NONDISP_HANDLE(VkImage) -VK_DEFINE_NONDISP_HANDLE(VkSemaphore) -VK_DEFINE_NONDISP_HANDLE(VkEvent) -VK_DEFINE_NONDISP_HANDLE(VkQueryPool) -VK_DEFINE_NONDISP_HANDLE(VkBufferView) -VK_DEFINE_NONDISP_HANDLE(VkImageView) -VK_DEFINE_NONDISP_HANDLE(VkShaderModule) -VK_DEFINE_NONDISP_HANDLE(VkShader) -VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) -VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout) -VK_DEFINE_NONDISP_HANDLE(VkRenderPass) -VK_DEFINE_NONDISP_HANDLE(VkPipeline) -VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) -VK_DEFINE_NONDISP_HANDLE(VkSampler) -VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) -VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) -VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) -VK_DEFINE_NONDISP_HANDLE(VkCmdPool) - -#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 256 -#define VK_UUID_LENGTH 16 -#define VK_MAX_MEMORY_TYPES 32 -#define VK_MAX_MEMORY_HEAPS 16 -#define VK_MAX_EXTENSION_NAME 256 -#define VK_MAX_DESCRIPTION 256 - - -typedef enum { - VK_SUCCESS = 0, - VK_UNSUPPORTED = 1, - VK_NOT_READY = 2, - VK_TIMEOUT = 3, - VK_EVENT_SET = 4, - VK_EVENT_RESET = 5, - VK_INCOMPLETE = 6, - 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_INCOMPATIBLE_DRIVER = -8, - VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER, - VK_RESULT_END_RANGE = VK_INCOMPLETE, - VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1), - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46, - VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, - VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum { - VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, - VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, - VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, - VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, - VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, - VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, - VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), - VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocType; - -typedef enum { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM = 1, - VK_FORMAT_R4G4_USCALED = 2, - VK_FORMAT_R4G4B4A4_UNORM = 3, - VK_FORMAT_R4G4B4A4_USCALED = 4, - VK_FORMAT_R5G6B5_UNORM = 5, - VK_FORMAT_R5G6B5_USCALED = 6, - VK_FORMAT_R5G5B5A1_UNORM = 7, - VK_FORMAT_R5G5B5A1_USCALED = 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_R8G8B8A8_UNORM = 30, - VK_FORMAT_R8G8B8A8_SNORM = 31, - VK_FORMAT_R8G8B8A8_USCALED = 32, - VK_FORMAT_R8G8B8A8_SSCALED = 33, - VK_FORMAT_R8G8B8A8_UINT = 34, - VK_FORMAT_R8G8B8A8_SINT = 35, - VK_FORMAT_R8G8B8A8_SRGB = 36, - VK_FORMAT_R10G10B10A2_UNORM = 37, - VK_FORMAT_R10G10B10A2_SNORM = 38, - VK_FORMAT_R10G10B10A2_USCALED = 39, - VK_FORMAT_R10G10B10A2_SSCALED = 40, - VK_FORMAT_R10G10B10A2_UINT = 41, - VK_FORMAT_R10G10B10A2_SINT = 42, - VK_FORMAT_R16_UNORM = 43, - VK_FORMAT_R16_SNORM = 44, - VK_FORMAT_R16_USCALED = 45, - VK_FORMAT_R16_SSCALED = 46, - VK_FORMAT_R16_UINT = 47, - VK_FORMAT_R16_SINT = 48, - VK_FORMAT_R16_SFLOAT = 49, - VK_FORMAT_R16G16_UNORM = 50, - VK_FORMAT_R16G16_SNORM = 51, - VK_FORMAT_R16G16_USCALED = 52, - VK_FORMAT_R16G16_SSCALED = 53, - VK_FORMAT_R16G16_UINT = 54, - VK_FORMAT_R16G16_SINT = 55, - VK_FORMAT_R16G16_SFLOAT = 56, - VK_FORMAT_R16G16B16_UNORM = 57, - VK_FORMAT_R16G16B16_SNORM = 58, - VK_FORMAT_R16G16B16_USCALED = 59, - VK_FORMAT_R16G16B16_SSCALED = 60, - VK_FORMAT_R16G16B16_UINT = 61, - VK_FORMAT_R16G16B16_SINT = 62, - VK_FORMAT_R16G16B16_SFLOAT = 63, - VK_FORMAT_R16G16B16A16_UNORM = 64, - VK_FORMAT_R16G16B16A16_SNORM = 65, - VK_FORMAT_R16G16B16A16_USCALED = 66, - VK_FORMAT_R16G16B16A16_SSCALED = 67, - VK_FORMAT_R16G16B16A16_UINT = 68, - VK_FORMAT_R16G16B16A16_SINT = 69, - VK_FORMAT_R16G16B16A16_SFLOAT = 70, - VK_FORMAT_R32_UINT = 71, - VK_FORMAT_R32_SINT = 72, - VK_FORMAT_R32_SFLOAT = 73, - VK_FORMAT_R32G32_UINT = 74, - VK_FORMAT_R32G32_SINT = 75, - VK_FORMAT_R32G32_SFLOAT = 76, - VK_FORMAT_R32G32B32_UINT = 77, - VK_FORMAT_R32G32B32_SINT = 78, - VK_FORMAT_R32G32B32_SFLOAT = 79, - VK_FORMAT_R32G32B32A32_UINT = 80, - VK_FORMAT_R32G32B32A32_SINT = 81, - VK_FORMAT_R32G32B32A32_SFLOAT = 82, - VK_FORMAT_R64_SFLOAT = 83, - VK_FORMAT_R64G64_SFLOAT = 84, - VK_FORMAT_R64G64B64_SFLOAT = 85, - VK_FORMAT_R64G64B64A64_SFLOAT = 86, - VK_FORMAT_R11G11B10_UFLOAT = 87, - VK_FORMAT_R9G9B9E5_UFLOAT = 88, - VK_FORMAT_D16_UNORM = 89, - VK_FORMAT_D24_UNORM_X8 = 90, - VK_FORMAT_D32_SFLOAT = 91, - VK_FORMAT_S8_UINT = 92, - VK_FORMAT_D16_UNORM_S8_UINT = 93, - VK_FORMAT_D24_UNORM_S8_UINT = 94, - VK_FORMAT_D32_SFLOAT_S8_UINT = 95, - VK_FORMAT_BC1_RGB_UNORM = 96, - VK_FORMAT_BC1_RGB_SRGB = 97, - VK_FORMAT_BC1_RGBA_UNORM = 98, - VK_FORMAT_BC1_RGBA_SRGB = 99, - VK_FORMAT_BC2_UNORM = 100, - VK_FORMAT_BC2_SRGB = 101, - VK_FORMAT_BC3_UNORM = 102, - VK_FORMAT_BC3_SRGB = 103, - VK_FORMAT_BC4_UNORM = 104, - VK_FORMAT_BC4_SNORM = 105, - VK_FORMAT_BC5_UNORM = 106, - VK_FORMAT_BC5_SNORM = 107, - VK_FORMAT_BC6H_UFLOAT = 108, - VK_FORMAT_BC6H_SFLOAT = 109, - VK_FORMAT_BC7_UNORM = 110, - VK_FORMAT_BC7_SRGB = 111, - VK_FORMAT_ETC2_R8G8B8_UNORM = 112, - VK_FORMAT_ETC2_R8G8B8_SRGB = 113, - VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, - VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, - VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, - VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, - VK_FORMAT_EAC_R11_UNORM = 118, - VK_FORMAT_EAC_R11_SNORM = 119, - VK_FORMAT_EAC_R11G11_UNORM = 120, - VK_FORMAT_EAC_R11G11_SNORM = 121, - VK_FORMAT_ASTC_4x4_UNORM = 122, - VK_FORMAT_ASTC_4x4_SRGB = 123, - VK_FORMAT_ASTC_5x4_UNORM = 124, - VK_FORMAT_ASTC_5x4_SRGB = 125, - VK_FORMAT_ASTC_5x5_UNORM = 126, - VK_FORMAT_ASTC_5x5_SRGB = 127, - VK_FORMAT_ASTC_6x5_UNORM = 128, - VK_FORMAT_ASTC_6x5_SRGB = 129, - VK_FORMAT_ASTC_6x6_UNORM = 130, - VK_FORMAT_ASTC_6x6_SRGB = 131, - VK_FORMAT_ASTC_8x5_UNORM = 132, - VK_FORMAT_ASTC_8x5_SRGB = 133, - VK_FORMAT_ASTC_8x6_UNORM = 134, - VK_FORMAT_ASTC_8x6_SRGB = 135, - VK_FORMAT_ASTC_8x8_UNORM = 136, - VK_FORMAT_ASTC_8x8_SRGB = 137, - VK_FORMAT_ASTC_10x5_UNORM = 138, - VK_FORMAT_ASTC_10x5_SRGB = 139, - VK_FORMAT_ASTC_10x6_UNORM = 140, - VK_FORMAT_ASTC_10x6_SRGB = 141, - VK_FORMAT_ASTC_10x8_UNORM = 142, - VK_FORMAT_ASTC_10x8_SRGB = 143, - VK_FORMAT_ASTC_10x10_UNORM = 144, - VK_FORMAT_ASTC_10x10_SRGB = 145, - VK_FORMAT_ASTC_12x10_UNORM = 146, - VK_FORMAT_ASTC_12x10_SRGB = 147, - VK_FORMAT_ASTC_12x12_UNORM = 148, - VK_FORMAT_ASTC_12x12_SRGB = 149, - VK_FORMAT_B4G4R4A4_UNORM = 150, - VK_FORMAT_B5G5R5A1_UNORM = 151, - VK_FORMAT_B5G6R5_UNORM = 152, - VK_FORMAT_B5G6R5_USCALED = 153, - VK_FORMAT_B8G8R8_UNORM = 154, - VK_FORMAT_B8G8R8_SNORM = 155, - VK_FORMAT_B8G8R8_USCALED = 156, - VK_FORMAT_B8G8R8_SSCALED = 157, - VK_FORMAT_B8G8R8_UINT = 158, - VK_FORMAT_B8G8R8_SINT = 159, - VK_FORMAT_B8G8R8_SRGB = 160, - VK_FORMAT_B8G8R8A8_UNORM = 161, - VK_FORMAT_B8G8R8A8_SNORM = 162, - VK_FORMAT_B8G8R8A8_USCALED = 163, - VK_FORMAT_B8G8R8A8_SSCALED = 164, - VK_FORMAT_B8G8R8A8_UINT = 165, - VK_FORMAT_B8G8R8A8_SINT = 166, - VK_FORMAT_B8G8R8A8_SRGB = 167, - VK_FORMAT_B10G10R10A2_UNORM = 168, - VK_FORMAT_B10G10R10A2_SNORM = 169, - VK_FORMAT_B10G10R10A2_USCALED = 170, - VK_FORMAT_B10G10R10A2_SSCALED = 171, - VK_FORMAT_B10G10R10A2_UINT = 172, - VK_FORMAT_B10G10R10A2_SINT = 173, - VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, - VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, - VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum { - 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_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum { - VK_IMAGE_TILING_LINEAR = 0, - VK_IMAGE_TILING_OPTIMAL = 1, - VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, - VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum { - 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_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum { - VK_IMAGE_ASPECT_COLOR = 0, - VK_IMAGE_ASPECT_DEPTH = 1, - VK_IMAGE_ASPECT_STENCIL = 2, - VK_IMAGE_ASPECT_METADATA = 3, - VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, - VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA, - VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1), - VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF -} VkImageAspect; - -typedef enum { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, - VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, - VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum { - 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_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), - VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSharingMode; - -typedef enum { - 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_SOURCE_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, - VK_IMAGE_LAYOUT_PREINITIALIZED = 8, - VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, - VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, - VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum { - 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_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum { - VK_CHANNEL_SWIZZLE_ZERO = 0, - VK_CHANNEL_SWIZZLE_ONE = 1, - VK_CHANNEL_SWIZZLE_R = 2, - VK_CHANNEL_SWIZZLE_G = 3, - VK_CHANNEL_SWIZZLE_B = 4, - VK_CHANNEL_SWIZZLE_A = 5, - VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, - VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, - VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), - VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkChannelSwizzle; - -typedef enum { - VK_SHADER_STAGE_VERTEX = 0, - VK_SHADER_STAGE_TESS_CONTROL = 1, - VK_SHADER_STAGE_TESS_EVALUATION = 2, - VK_SHADER_STAGE_GEOMETRY = 3, - VK_SHADER_STAGE_FRAGMENT = 4, - VK_SHADER_STAGE_COMPUTE = 5, - VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, - VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, - VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), - VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF -} VkShaderStage; - -typedef enum { - VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, - VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, - VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, - VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), - VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputStepRate; - -typedef enum { - 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_ADJ = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH = 10, - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, - VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum { - VK_FILL_MODE_POINTS = 0, - VK_FILL_MODE_WIREFRAME = 1, - VK_FILL_MODE_SOLID = 2, - VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, - VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, - VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), - VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF -} VkFillMode; - -typedef enum { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT = 1, - VK_CULL_MODE_BACK = 2, - VK_CULL_MODE_FRONT_AND_BACK = 3, - VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, - VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, - VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), - VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF -} VkCullMode; - -typedef enum { - VK_FRONT_FACE_CCW = 0, - VK_FRONT_FACE_CW = 1, - VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, - VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, - VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_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_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INC_CLAMP = 3, - VK_STENCIL_OP_DEC_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INC_WRAP = 6, - VK_STENCIL_OP_DEC_WRAP = 7, - VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, - VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, - VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum { - 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_NOOP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIV = 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_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum { - VK_BLEND_ZERO = 0, - VK_BLEND_ONE = 1, - VK_BLEND_SRC_COLOR = 2, - VK_BLEND_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_DEST_COLOR = 4, - VK_BLEND_ONE_MINUS_DEST_COLOR = 5, - VK_BLEND_SRC_ALPHA = 6, - VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_DEST_ALPHA = 8, - VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, - VK_BLEND_CONSTANT_COLOR = 10, - VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_CONSTANT_ALPHA = 12, - VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_SRC_ALPHA_SATURATE = 14, - VK_BLEND_SRC1_COLOR = 15, - VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_SRC1_ALPHA = 17, - VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, - VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, - VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), - VK_BLEND_MAX_ENUM = 0x7FFFFFFF -} VkBlend; - -typedef enum { - 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_BEGIN_RANGE = VK_BLEND_OP_ADD, - VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, - VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum { - 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_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, - VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, - VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), - VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF -} VkDynamicState; - -typedef enum { - VK_TEX_FILTER_NEAREST = 0, - VK_TEX_FILTER_LINEAR = 1, - VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, - VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, - VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), - VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkTexFilter; - -typedef enum { - VK_TEX_MIPMAP_MODE_BASE = 0, - VK_TEX_MIPMAP_MODE_NEAREST = 1, - VK_TEX_MIPMAP_MODE_LINEAR = 2, - VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, - VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, - VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), - VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkTexMipmapMode; - -typedef enum { - VK_TEX_ADDRESS_MODE_WRAP = 0, - VK_TEX_ADDRESS_MODE_MIRROR = 1, - VK_TEX_ADDRESS_MODE_CLAMP = 2, - VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3, - VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4, - VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP, - VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER, - VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1), - VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF -} VkTexAddressMode; - -typedef enum { - 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_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum { - 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_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, - VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, - VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum { - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, - VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, - VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, - VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), - VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolUsage; - -typedef enum { - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, - VK_DESCRIPTOR_SET_USAGE_STATIC = 1, - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, - VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, - VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), - VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetUsage; - -typedef enum { - 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_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum { - 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_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum { - VK_PIPELINE_BIND_POINT_COMPUTE = 0, - VK_PIPELINE_BIND_POINT_GRAPHICS = 1, - VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, - VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, - VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum { - VK_CMD_BUFFER_LEVEL_PRIMARY = 0, - VK_CMD_BUFFER_LEVEL_SECONDARY = 1, - VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, - VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, - VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), - VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCmdBufferLevel; - -typedef enum { - 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_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum { - VK_TIMESTAMP_TYPE_TOP = 0, - VK_TIMESTAMP_TYPE_BOTTOM = 1, - VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, - VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, - VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), - VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkTimestampType; - -typedef enum { - VK_RENDER_PASS_CONTENTS_INLINE = 0, - VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, - VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, - VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, - VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), - VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassContents; - - -typedef enum { - 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_SOURCE_BIT = 0x00000400, - VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800, -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum { - VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DESTINATION_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, -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; - -typedef enum { - 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, -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum { - 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, -} VkSampleCountFlagBits; -typedef VkFlags VkSampleCountFlags; - -typedef enum { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_DMA_BIT = 0x00000004, - VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, - VK_QUEUE_EXTENDED_BIT = 0x40000000, -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; - -typedef enum { - VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum { - VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; -typedef VkFlags VkMemoryMapFlags; - -typedef enum { - VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, - VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, - VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, -} VkSparseImageFormatFlagBits; -typedef VkFlags VkSparseImageFormatFlags; - -typedef enum { - VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, -} VkSparseMemoryBindFlagBits; -typedef VkFlags VkSparseMemoryBindFlags; - -typedef enum { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; -typedef VkFlags VkEventCreateFlags; - -typedef enum { - VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; - -typedef enum { - VK_QUERY_RESULT_DEFAULT = 0, - 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, -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum { - VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DESTINATION_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, -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; - -typedef enum { - VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum { - VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, - VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, -} VkImageViewCreateFlagBits; -typedef VkFlags VkImageViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; -typedef VkFlags VkShaderCreateFlags; - -typedef enum { - VK_CHANNEL_R_BIT = 0x00000001, - VK_CHANNEL_G_BIT = 0x00000002, - VK_CHANNEL_B_BIT = 0x00000004, - VK_CHANNEL_A_BIT = 0x00000008, -} VkChannelFlagBits; -typedef VkFlags VkChannelFlags; - -typedef enum { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; - -typedef enum { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESS_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 = 0x7FFFFFFF, -} VkShaderStageFlagBits; -typedef VkFlags VkShaderStageFlags; - -typedef enum { - VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, -} VkAttachmentDescriptionFlagBits; -typedef VkFlags VkAttachmentDescriptionFlags; - -typedef enum { - VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, -} VkSubpassDescriptionFlagBits; -typedef VkFlags VkSubpassDescriptionFlags; - -typedef enum { - 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_TESS_CONTROL_SHADER_BIT = 0x00000010, - VK_PIPELINE_STAGE_TESS_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_HOST_BIT = 0x00002000, - VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, - VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, -} VkPipelineStageFlagBits; -typedef VkFlags VkPipelineStageFlags; - -typedef enum { - VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, - VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, - VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, - VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, - VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, -} VkMemoryOutputFlagBits; -typedef VkFlags VkMemoryOutputFlags; - -typedef enum { - VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, - VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, - VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, - VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, - VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, - VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, - VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, - VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, - VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, - VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, -} VkMemoryInputFlagBits; -typedef VkFlags VkMemoryInputFlags; - -typedef enum { - VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, -} VkCmdPoolCreateFlagBits; -typedef VkFlags VkCmdPoolCreateFlags; - -typedef enum { - VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, -} VkCmdPoolResetFlagBits; -typedef VkFlags VkCmdPoolResetFlags; -typedef VkFlags VkCmdBufferCreateFlags; - -typedef enum { - VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, - VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, - VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, - VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, - VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, -} VkCmdBufferOptimizeFlagBits; -typedef VkFlags VkCmdBufferOptimizeFlags; - -typedef enum { - VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, -} VkCmdBufferResetFlagBits; -typedef VkFlags VkCmdBufferResetFlags; - -typedef enum { - VK_STENCIL_FACE_NONE = 0, - VK_STENCIL_FACE_FRONT_BIT = 0x00000001, - VK_STENCIL_FACE_BACK_BIT = 0x00000002, -} VkStencilFaceFlagBits; -typedef VkFlags VkStencilFaceFlags; - -typedef enum { - VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef void* (VKAPI *PFN_vkAllocFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocType allocType); - -typedef void (VKAPI *PFN_vkFreeFunction)( - void* pUserData, - void* pMem); - -typedef void (VKAPI *PFN_vkVoidFunction)(void); - -typedef struct { - VkStructureType sType; - const void* pNext; - const char* pAppName; - uint32_t appVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef struct { - void* pUserData; - PFN_vkAllocFunction pfnAlloc; - PFN_vkFreeFunction pfnFree; -} VkAllocCallbacks; - -typedef struct { - VkStructureType sType; - const void* pNext; - const VkApplicationInfo* pAppInfo; - const VkAllocCallbacks* pAllocCb; - uint32_t layerCount; - const char*const* ppEnabledLayerNames; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef struct { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSourceBlend; - VkBool32 logicOp; - VkBool32 multiDrawIndirect; - VkBool32 depthClip; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 occlusionQueryNonConservative; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexSideEffects; - VkBool32 tessellationSideEffects; - VkBool32 geometrySideEffects; - VkBool32 fragmentSideEffects; - VkBool32 shaderTessellationPointSize; - VkBool32 shaderGeometryPointSize; - VkBool32 shaderImageGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLOD; - VkBool32 alphaToOne; - VkBool32 sparseBinding; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyAliased; -} VkPhysicalDeviceFeatures; - -typedef struct { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; - VkFormatFeatureFlags bufferFeatures; -} VkFormatProperties; - -typedef struct { - int32_t width; - int32_t height; - int32_t depth; -} VkExtent3D; - -typedef struct { - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArraySize; - VkSampleCountFlags sampleCounts; - VkDeviceSize maxResourceSize; -} VkImageFormatProperties; - -typedef struct { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - VkSampleCountFlags sampleCounts; - uint32_t maxTexelBufferSize; - uint32_t maxUniformBufferSize; - uint32_t maxStorageBufferSize; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - VkDeviceSize bufferImageGranularity; - VkDeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessGenLevel; - uint32_t maxTessPatchSize; - uint32_t maxTessControlPerVertexInputComponents; - uint32_t maxTessControlPerVertexOutputComponents; - uint32_t maxTessControlPerPatchOutputComponents; - uint32_t maxTessControlTotalOutputComponents; - uint32_t maxTessEvaluationInputComponents; - uint32_t maxTessEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputBuffers; - uint32_t maxFragmentDualSourceBuffers; - 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 maxDrawIndirectInstanceCount; - VkBool32 primitiveRestartForPatches; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - uint32_t minMemoryMapAlignment; - uint32_t minTexelBufferOffsetAlignment; - uint32_t minUniformBufferOffsetAlignment; - uint32_t minStorageBufferOffsetAlignment; - uint32_t minTexelOffset; - uint32_t maxTexelOffset; - uint32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - uint32_t maxFramebufferColorSamples; - uint32_t maxFramebufferDepthSamples; - uint32_t maxFramebufferStencilSamples; - uint32_t maxColorAttachments; - uint32_t maxSampledImageColorSamples; - uint32_t maxSampledImageDepthSamples; - uint32_t maxSampledImageIntegerSamples; - uint32_t maxStorageImageSamples; - uint32_t maxSampleMaskWords; - uint64_t timestampFrequency; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; -} VkPhysicalDeviceLimits; - -typedef struct { - VkBool32 residencyStandard2DBlockShape; - VkBool32 residencyStandard2DMSBlockShape; - VkBool32 residencyStandard3DBlockShape; - VkBool32 residencyAlignedMipSize; - VkBool32 residencyNonResident; - VkBool32 residencyNonResidentStrict; -} VkPhysicalDeviceSparseProperties; - -typedef struct { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorId; - uint32_t deviceId; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; - uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; - VkPhysicalDeviceLimits limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties; - -typedef struct { - VkQueueFlags queueFlags; - uint32_t queueCount; - VkBool32 supportsTimestamps; -} VkQueueFamilyProperties; - -typedef struct { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - uint32_t queueCount; -} VkDeviceQueueCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueRecordCount; - const VkDeviceQueueCreateInfo* pRequestedQueues; - uint32_t layerCount; - const char*const* ppEnabledLayerNames; - uint32_t extensionCount; - const char*const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; -} VkDeviceCreateInfo; - -typedef struct { - char extName[VK_MAX_EXTENSION_NAME]; - uint32_t specVersion; -} VkExtensionProperties; - -typedef struct { - char layerName[VK_MAX_EXTENSION_NAME]; - uint32_t specVersion; - uint32_t implVersion; - char description[VK_MAX_DESCRIPTION]; -} VkLayerProperties; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceMemory mem; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct { - VkDeviceSize size; - VkDeviceSize alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct { - VkImageAspect aspect; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; - -typedef struct { - VkSparseImageFormatProperties formatProps; - uint32_t imageMipTailStartLOD; - VkDeviceSize imageMipTailSize; - VkDeviceSize imageMipTailOffset; - VkDeviceSize imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct { - VkDeviceSize rangeOffset; - VkDeviceSize rangeSize; - VkDeviceSize memOffset; - VkDeviceMemory mem; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBindInfo; - -typedef struct { - VkImageAspect aspect; - uint32_t mipLevel; - uint32_t arrayLayer; -} VkImageSubresource; - -typedef struct { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceSize memOffset; - VkDeviceMemory mem; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBindInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkQueryType queryType; - uint32_t slots; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkBufferCreateFlags flags; - VkSharingMode sharingMode; - uint32_t queueFamilyCount; - const uint32_t* pQueueFamilyIndices; -} VkBufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arraySize; - uint32_t samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; - VkSharingMode sharingMode; - uint32_t queueFamilyCount; - const uint32_t* pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo; - -typedef struct { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct { - VkChannelSwizzle r; - VkChannelSwizzle g; - VkChannelSwizzle b; - VkChannelSwizzle a; -} VkChannelMapping; - -typedef struct { - VkImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t mipLevels; - uint32_t baseArrayLayer; - uint32_t arraySize; -} VkImageSubresourceRange; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkChannelMapping channels; - VkImageSubresourceRange subresourceRange; - VkImageViewCreateFlags flags; -} VkImageViewCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - size_t codeSize; - const void* pCode; - VkShaderModuleCreateFlags flags; -} VkShaderModuleCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkShaderModule module; - const char* pName; - VkShaderCreateFlags flags; - VkShaderStage stage; -} VkShaderCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - size_t initialSize; - const void* initialData; - size_t maxSize; -} VkPipelineCacheCreateInfo; - -typedef struct { - uint32_t constantId; - size_t size; - uint32_t offset; -} VkSpecializationMapEntry; - -typedef struct { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMap; - size_t dataSize; - const void* pData; -} VkSpecializationInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkShaderStage stage; - VkShader shader; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct { - uint32_t binding; - uint32_t strideInBytes; - VkVertexInputStepRate stepRate; -} VkVertexInputBindingDescription; - -typedef struct { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offsetInBytes; -} VkVertexInputAttributeDescription; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t attributeCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo; - -typedef struct { - float originX; - float originY; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct { - int32_t width; - int32_t height; -} VkExtent2D; - -typedef struct { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportCount; - const VkViewport* pViewports; - uint32_t scissorCount; - const VkRect2D* pScissors; -} VkPipelineViewportStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBool32 depthClipEnable; - VkBool32 rasterizerDiscardEnable; - VkFillMode fillMode; - VkCullMode cullMode; - VkFrontFace frontFace; - VkBool32 depthBiasEnable; - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float lineWidth; -} VkPipelineRasterStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t rasterSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - const VkSampleMask* pSampleMask; -} VkPipelineMultisampleStateCreateInfo; - -typedef struct { - VkStencilOp stencilFailOp; - VkStencilOp stencilPassOp; - VkStencilOp stencilDepthFailOp; - VkCompareOp stencilCompareOp; - uint32_t stencilCompareMask; - uint32_t stencilWriteMask; - uint32_t stencilReference; -} VkStencilOpState; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct { - VkBool32 blendEnable; - VkBlend srcBlendColor; - VkBlend destBlendColor; - VkBlendOp blendOpColor; - VkBlend srcBlendAlpha; - VkBlend destBlendAlpha; - VkBlendOp blendOpAlpha; - VkChannelFlags channelWriteMask; -} VkPipelineColorBlendAttachmentState; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkBool32 alphaToCoverageEnable; - VkBool32 alphaToOneEnable; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState* pAttachments; - float blendConst[4]; -} VkPipelineColorBlendStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t dynamicStateCount; - const VkDynamicState* pDynamicStates; -} VkPipelineDynamicStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; - const VkPipelineViewportStateCreateInfo* pViewportState; - const VkPipelineRasterStateCreateInfo* pRasterState; - const VkPipelineMultisampleStateCreateInfo* pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo* pColorBlendState; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineCreateFlags flags; - VkPipelineLayout layout; - VkRenderPass renderPass; - uint32_t subpass; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateInfo stage; - VkPipelineCreateFlags flags; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct { - VkShaderStageFlags stageFlags; - uint32_t start; - uint32_t length; -} VkPushConstantRange; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkTexFilter magFilter; - VkTexFilter minFilter; - VkTexMipmapMode mipMode; - VkTexAddressMode addressModeU; - VkTexAddressMode addressModeV; - VkTexAddressMode addressModeW; - float mipLodBias; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo; - -typedef struct { - VkDescriptorType descriptorType; - uint32_t arraySize; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t count; - const VkDescriptorSetLayoutBinding* pBinding; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct { - VkDescriptorType type; - uint32_t count; -} VkDescriptorTypeCount; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorPoolUsage poolUsage; - uint32_t maxSets; - uint32_t count; - const VkDescriptorTypeCount* pTypeCount; -} VkDescriptorPoolCreateInfo; - -typedef struct { - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize range; -} VkDescriptorBufferInfo; - -typedef struct { - VkBufferView bufferView; - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; - VkDescriptorBufferInfo bufferInfo; -} VkDescriptorInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorSet destSet; - uint32_t destBinding; - uint32_t destArrayElement; - uint32_t count; - VkDescriptorType descriptorType; - const VkDescriptorInfo* pDescriptors; -} VkWriteDescriptorSet; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet destSet; - uint32_t destBinding; - uint32_t destArrayElement; - uint32_t count; -} VkCopyDescriptorSet; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t attachmentCount; - const VkImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkFormat format; - uint32_t samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; - VkAttachmentDescriptionFlags flags; -} VkAttachmentDescription; - -typedef struct { - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkSubpassDescriptionFlags flags; - uint32_t inputCount; - const VkAttachmentReference* pInputAttachments; - uint32_t colorCount; - const VkAttachmentReference* pColorAttachments; - const VkAttachmentReference* pResolveAttachments; - VkAttachmentReference depthStencilAttachment; - uint32_t preserveCount; - const VkAttachmentReference* pPreserveAttachments; -} VkSubpassDescription; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t srcSubpass; - uint32_t destSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags destStageMask; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - VkBool32 byRegion; -} VkSubpassDependency; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkAttachmentDescription* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency* pDependencies; -} VkRenderPassCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - VkCmdPoolCreateFlags flags; -} VkCmdPoolCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkCmdPool cmdPool; - VkCmdBufferLevel level; - VkCmdBufferCreateFlags flags; -} VkCmdBufferCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkCmdBufferOptimizeFlags flags; - VkRenderPass renderPass; - uint32_t subpass; - VkFramebuffer framebuffer; -} VkCmdBufferBeginInfo; - -typedef struct { - VkDeviceSize srcOffset; - VkDeviceSize destOffset; - VkDeviceSize copySize; -} VkBufferCopy; - -typedef struct { - VkImageAspect aspect; - uint32_t mipLevel; - uint32_t arrayLayer; - uint32_t arraySize; -} VkImageSubresourceCopy; - -typedef struct { - VkImageSubresourceCopy srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceCopy destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct { - VkImageSubresourceCopy srcSubresource; - VkOffset3D srcOffset; - VkExtent3D srcExtent; - VkImageSubresourceCopy destSubresource; - VkOffset3D destOffset; - VkExtent3D destExtent; -} VkImageBlit; - -typedef struct { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceCopy imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef union { - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; -} VkClearColorValue; - -typedef struct { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - -typedef struct { - VkOffset3D offset; - VkExtent3D extent; -} VkRect3D; - -typedef struct { - VkImageSubresourceCopy srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceCopy destSubresource; - VkOffset3D destOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef union { - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -} VkClearValue; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - const VkClearValue* pClearValues; -} VkRenderPassBeginInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - uint32_t srcQueueFamilyIndex; - uint32_t destQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCmd; - -typedef struct { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCmd; - -typedef struct { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCmd; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t destQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct { - VkStructureType sType; - const void* pNext; - VkMemoryOutputFlags outputMask; - VkMemoryInputFlags inputMask; -} VkMemoryBarrier; - - -typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); -typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); -typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); -typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); -typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); -typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); -typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); -typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); -typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); -typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); -typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset); -typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); -typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); -typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); -typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); -typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); -typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); -typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); -typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); -typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); -typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); -typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); -typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); -typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); -typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); -typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); -typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); -typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); -typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); -typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); -typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); -typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); -typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); -typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); -typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); -typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); -typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); -typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); -typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); -typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); -typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); -typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); -typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); -typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); -typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); -typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); -typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); -typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); -typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); -typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); -typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); -typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); -typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); -typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); -typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); -typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); -typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); -typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); -typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth); -typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias); -typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]); -typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds); -typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); -typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); -typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); -typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); -typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); -typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); -typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); -typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); -typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); -typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); -typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects); -typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers); -typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); -typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); -typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); -typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); -typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); -typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); -typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); -typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents); -typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); -typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); - -#ifdef VK_PROTOTYPES -VkResult VKAPI vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - VkInstance* pInstance); - -void VKAPI vkDestroyInstance( - VkInstance instance); - -VkResult VKAPI vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VkResult VKAPI vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); - -VkResult VKAPI vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties); - -VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties); - -VkResult VKAPI vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); - -VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pCount, - VkQueueFamilyProperties* pQueueFamilyProperties); - -VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties); - -PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( - VkInstance instance, - const char* pName); - -PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( - VkDevice device, - const char* pName); - -VkResult VKAPI vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - VkDevice* pDevice); - -void VKAPI vkDestroyDevice( - VkDevice device); - -VkResult VKAPI vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pCount, - VkExtensionProperties* pProperties); - -VkResult VKAPI vkEnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pCount, - VkExtensionProperties* pProperties); - -VkResult VKAPI vkEnumerateInstanceLayerProperties( - uint32_t* pCount, - VkLayerProperties* pProperties); - -VkResult VKAPI vkEnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pCount, - VkLayerProperties* pProperties); - -VkResult VKAPI vkGetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VkResult VKAPI vkQueueSubmit( - VkQueue queue, - uint32_t cmdBufferCount, - const VkCmdBuffer* pCmdBuffers, - VkFence fence); - -VkResult VKAPI vkQueueWaitIdle( - VkQueue queue); - -VkResult VKAPI vkDeviceWaitIdle( - VkDevice device); - -VkResult VKAPI vkAllocMemory( - VkDevice device, - const VkMemoryAllocInfo* pAllocInfo, - VkDeviceMemory* pMem); - -void VKAPI vkFreeMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkMapMemory( - VkDevice device, - VkDeviceMemory mem, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -void VKAPI vkUnmapMemory( - VkDevice device, - VkDeviceMemory mem); - -VkResult VKAPI vkFlushMappedMemoryRanges( - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); - -VkResult VKAPI vkInvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges); - -VkResult VKAPI vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); - -VkResult VKAPI vkBindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkBindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory mem, - VkDeviceSize memOffset); - -VkResult VKAPI vkGetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); - -VkResult VKAPI vkGetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); - -VkResult VKAPI vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pNumRequirements, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); - -VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - uint32_t samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pNumProperties, - VkSparseImageFormatProperties* pProperties); - -VkResult VKAPI vkQueueBindSparseBufferMemory( - VkQueue queue, - VkBuffer buffer, - uint32_t numBindings, - const VkSparseMemoryBindInfo* pBindInfo); - -VkResult VKAPI vkQueueBindSparseImageOpaqueMemory( - VkQueue queue, - VkImage image, - uint32_t numBindings, - const VkSparseMemoryBindInfo* pBindInfo); - -VkResult VKAPI vkQueueBindSparseImageMemory( - VkQueue queue, - VkImage image, - uint32_t numBindings, - const VkSparseImageMemoryBindInfo* pBindInfo); - -VkResult VKAPI vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - VkFence* pFence); - -void VKAPI vkDestroyFence( - VkDevice device, - VkFence fence); - -VkResult VKAPI vkResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); - -VkResult VKAPI vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VkResult VKAPI vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); - -VkResult VKAPI vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - VkSemaphore* pSemaphore); - -void VKAPI vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore); - -VkResult VKAPI vkQueueSignalSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkQueueWaitSemaphore( - VkQueue queue, - VkSemaphore semaphore); - -VkResult VKAPI vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - VkEvent* pEvent); - -void VKAPI vkDestroyEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkGetEventStatus( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkSetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkResetEvent( - VkDevice device, - VkEvent event); - -VkResult VKAPI vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - VkQueryPool* pQueryPool); - -void VKAPI vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool); - -VkResult VKAPI vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - size_t* pDataSize, - void* pData, - VkQueryResultFlags flags); - -VkResult VKAPI vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - VkBuffer* pBuffer); - -void VKAPI vkDestroyBuffer( - VkDevice device, - VkBuffer buffer); - -VkResult VKAPI vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - VkBufferView* pView); - -void VKAPI vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView); - -VkResult VKAPI vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - VkImage* pImage); - -void VKAPI vkDestroyImage( - VkDevice device, - VkImage image); - -VkResult VKAPI vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); - -VkResult VKAPI vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - VkImageView* pView); - -void VKAPI vkDestroyImageView( - VkDevice device, - VkImageView imageView); - -VkResult VKAPI vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModule* pShaderModule); - -void VKAPI vkDestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule); - -VkResult VKAPI vkCreateShader( - VkDevice device, - const VkShaderCreateInfo* pCreateInfo, - VkShader* pShader); - -void VKAPI vkDestroyShader( - VkDevice device, - VkShader shader); - -VkResult VKAPI vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - VkPipelineCache* pPipelineCache); - -void VKAPI vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache); - -size_t VKAPI vkGetPipelineCacheSize( - VkDevice device, - VkPipelineCache pipelineCache); - -VkResult VKAPI vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - void* pData); - -VkResult VKAPI vkMergePipelineCaches( - VkDevice device, - VkPipelineCache destCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); - -VkResult VKAPI vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - -VkResult VKAPI vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t count, - const VkComputePipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines); - -void VKAPI vkDestroyPipeline( - VkDevice device, - VkPipeline pipeline); - -VkResult VKAPI vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - VkPipelineLayout* pPipelineLayout); - -void VKAPI vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout); - -VkResult VKAPI vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - VkSampler* pSampler); - -void VKAPI vkDestroySampler( - VkDevice device, - VkSampler sampler); - -VkResult VKAPI vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout); - -void VKAPI vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout); - -VkResult VKAPI vkCreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool); - -void VKAPI vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool); - -VkResult VKAPI vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool); - -VkResult VKAPI vkAllocDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorSetUsage setUsage, - uint32_t count, - const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets); - -VkResult VKAPI vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t count, - const VkDescriptorSet* pDescriptorSets); - -void VKAPI vkUpdateDescriptorSets( - VkDevice device, - uint32_t writeCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t copyCount, - const VkCopyDescriptorSet* pDescriptorCopies); - -VkResult VKAPI vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - VkFramebuffer* pFramebuffer); - -void VKAPI vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer); - -VkResult VKAPI vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass); - -void VKAPI vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass); - -VkResult VKAPI vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); - -VkResult VKAPI vkCreateCommandPool( - VkDevice device, - const VkCmdPoolCreateInfo* pCreateInfo, - VkCmdPool* pCmdPool); - -void VKAPI vkDestroyCommandPool( - VkDevice device, - VkCmdPool cmdPool); - -VkResult VKAPI vkResetCommandPool( - VkDevice device, - VkCmdPool cmdPool, - VkCmdPoolResetFlags flags); - -VkResult VKAPI vkCreateCommandBuffer( - VkDevice device, - const VkCmdBufferCreateInfo* pCreateInfo, - VkCmdBuffer* pCmdBuffer); - -void VKAPI vkDestroyCommandBuffer( - VkDevice device, - VkCmdBuffer commandBuffer); - -VkResult VKAPI vkBeginCommandBuffer( - VkCmdBuffer cmdBuffer, - const VkCmdBufferBeginInfo* pBeginInfo); - -VkResult VKAPI vkEndCommandBuffer( - VkCmdBuffer cmdBuffer); - -VkResult VKAPI vkResetCommandBuffer( - VkCmdBuffer cmdBuffer, - VkCmdBufferResetFlags flags); - -void VKAPI vkCmdBindPipeline( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -void VKAPI vkCmdSetViewport( - VkCmdBuffer cmdBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); - -void VKAPI vkCmdSetScissor( - VkCmdBuffer cmdBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); - -void VKAPI vkCmdSetLineWidth( - VkCmdBuffer cmdBuffer, - float lineWidth); - -void VKAPI vkCmdSetDepthBias( - VkCmdBuffer cmdBuffer, - float depthBias, - float depthBiasClamp, - float slopeScaledDepthBias); - -void VKAPI vkCmdSetBlendConstants( - VkCmdBuffer cmdBuffer, - const float blendConst[4]); - -void VKAPI vkCmdSetDepthBounds( - VkCmdBuffer cmdBuffer, - float minDepthBounds, - float maxDepthBounds); - -void VKAPI vkCmdSetStencilCompareMask( - VkCmdBuffer cmdBuffer, - VkStencilFaceFlags faceMask, - uint32_t stencilCompareMask); - -void VKAPI vkCmdSetStencilWriteMask( - VkCmdBuffer cmdBuffer, - VkStencilFaceFlags faceMask, - uint32_t stencilWriteMask); - -void VKAPI vkCmdSetStencilReference( - VkCmdBuffer cmdBuffer, - VkStencilFaceFlags faceMask, - uint32_t stencilReference); - -void VKAPI vkCmdBindDescriptorSets( - VkCmdBuffer cmdBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -void VKAPI vkCmdBindIndexBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -void VKAPI vkCmdBindVertexBuffers( - VkCmdBuffer cmdBuffer, - uint32_t startBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -void VKAPI vkCmdDraw( - VkCmdBuffer cmdBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance); - -void VKAPI vkCmdDrawIndexed( - VkCmdBuffer cmdBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance); - -void VKAPI vkCmdDrawIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDrawIndexedIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t count, - uint32_t stride); - -void VKAPI vkCmdDispatch( - VkCmdBuffer cmdBuffer, - uint32_t x, - uint32_t y, - uint32_t z); - -void VKAPI vkCmdDispatchIndirect( - VkCmdBuffer cmdBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -void VKAPI vkCmdCopyBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -void VKAPI vkCmdCopyImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -void VKAPI vkCmdBlitImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkTexFilter filter); - -void VKAPI vkCmdCopyBufferToImage( - VkCmdBuffer cmdBuffer, - VkBuffer srcBuffer, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdCopyImageToBuffer( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer destBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -void VKAPI vkCmdUpdateBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize dataSize, - const uint32_t* pData); - -void VKAPI vkCmdFillBuffer( - VkCmdBuffer cmdBuffer, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize fillSize, - uint32_t data); - -void VKAPI vkCmdClearColorImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearDepthStencilImage( - VkCmdBuffer cmdBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -void VKAPI vkCmdClearColorAttachment( - VkCmdBuffer cmdBuffer, - uint32_t colorAttachment, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rectCount, - const VkRect3D* pRects); - -void VKAPI vkCmdClearDepthStencilAttachment( - VkCmdBuffer cmdBuffer, - VkImageAspectFlags aspectMask, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rectCount, - const VkRect3D* pRects); - -void VKAPI vkCmdResolveImage( - VkCmdBuffer cmdBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage destImage, - VkImageLayout destImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -void VKAPI vkCmdSetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -void VKAPI vkCmdResetEvent( - VkCmdBuffer cmdBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -void VKAPI vkCmdWaitEvents( - VkCmdBuffer cmdBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - -void VKAPI vkCmdPipelineBarrier( - VkCmdBuffer cmdBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - VkBool32 byRegion, - uint32_t memBarrierCount, - const void* const* ppMemBarriers); - -void VKAPI vkCmdBeginQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot, - VkQueryControlFlags flags); - -void VKAPI vkCmdEndQuery( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t slot); - -void VKAPI vkCmdResetQueryPool( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount); - -void VKAPI vkCmdWriteTimestamp( - VkCmdBuffer cmdBuffer, - VkTimestampType timestampType, - VkBuffer destBuffer, - VkDeviceSize destOffset); - -void VKAPI vkCmdCopyQueryPoolResults( - VkCmdBuffer cmdBuffer, - VkQueryPool queryPool, - uint32_t startQuery, - uint32_t queryCount, - VkBuffer destBuffer, - VkDeviceSize destOffset, - VkDeviceSize destStride, - VkQueryResultFlags flags); - -void VKAPI vkCmdPushConstants( - VkCmdBuffer cmdBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t start, - uint32_t length, - const void* values); - -void VKAPI vkCmdBeginRenderPass( - VkCmdBuffer cmdBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkRenderPassContents contents); - -void VKAPI vkCmdNextSubpass( - VkCmdBuffer cmdBuffer, - VkRenderPassContents contents); - -void VKAPI vkCmdEndRenderPass( - VkCmdBuffer cmdBuffer); - -void VKAPI vkCmdExecuteCommands( - VkCmdBuffer cmdBuffer, - uint32_t cmdBuffersCount, - const VkCmdBuffer* pCmdBuffers); -#endif - -#ifdef __cplusplus -} -#endif - -#endif