/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-#define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 138, 0)
#define VK_MAX_PHYSICAL_DEVICE_NAME 256
#define VK_MAX_EXTENSION_NAME 256
+#define VK_UUID_LENGTH 16
+#define VK_MAX_MEMORY_TYPES 32
+#define VK_MAX_MEMORY_HEAPS 16
+#define VK_MAX_DESCRIPTION 256
+
+VK_DEFINE_HANDLE (VkInstance, HANDLE_TYPE_INSTANCE);
+VK_DEFINE_HANDLE (VkPhysicalDevice, HANDLE_TYPE_PHYSICAL_DEVICE);
+VK_DEFINE_HANDLE (VkDevice, HANDLE_TYPE_DEVICE);
+VK_DEFINE_HANDLE (VkQueue, HANDLE_TYPE_QUEUE);
+VK_DEFINE_HANDLE (VkCmdBuffer, HANDLE_TYPE_CMD_BUFFER);
+VK_DEFINE_NONDISP_HANDLE (VkFence, HANDLE_TYPE_FENCE);
+VK_DEFINE_NONDISP_HANDLE (VkDeviceMemory, HANDLE_TYPE_DEVICE_MEMORY);
+VK_DEFINE_NONDISP_HANDLE (VkBuffer, HANDLE_TYPE_BUFFER);
+VK_DEFINE_NONDISP_HANDLE (VkImage, HANDLE_TYPE_IMAGE);
+VK_DEFINE_NONDISP_HANDLE (VkSemaphore, HANDLE_TYPE_SEMAPHORE);
+VK_DEFINE_NONDISP_HANDLE (VkEvent, HANDLE_TYPE_EVENT);
+VK_DEFINE_NONDISP_HANDLE (VkQueryPool, HANDLE_TYPE_QUERY_POOL);
+VK_DEFINE_NONDISP_HANDLE (VkBufferView, HANDLE_TYPE_BUFFER_VIEW);
+VK_DEFINE_NONDISP_HANDLE (VkImageView, HANDLE_TYPE_IMAGE_VIEW);
+VK_DEFINE_NONDISP_HANDLE (VkAttachmentView, HANDLE_TYPE_ATTACHMENT_VIEW);
+VK_DEFINE_NONDISP_HANDLE (VkShaderModule, HANDLE_TYPE_SHADER_MODULE);
+VK_DEFINE_NONDISP_HANDLE (VkShader, HANDLE_TYPE_SHADER);
+VK_DEFINE_NONDISP_HANDLE (VkPipelineCache, HANDLE_TYPE_PIPELINE_CACHE);
+VK_DEFINE_NONDISP_HANDLE (VkPipelineLayout, HANDLE_TYPE_PIPELINE_LAYOUT);
+VK_DEFINE_NONDISP_HANDLE (VkRenderPass, HANDLE_TYPE_RENDER_PASS);
+VK_DEFINE_NONDISP_HANDLE (VkPipeline, HANDLE_TYPE_PIPELINE);
+VK_DEFINE_NONDISP_HANDLE (VkDescriptorSetLayout, HANDLE_TYPE_DESCRIPTOR_SET_LAYOUT);
+VK_DEFINE_NONDISP_HANDLE (VkSampler, HANDLE_TYPE_SAMPLER);
+VK_DEFINE_NONDISP_HANDLE (VkDescriptorPool, HANDLE_TYPE_DESCRIPTOR_POOL);
+VK_DEFINE_NONDISP_HANDLE (VkDescriptorSet, HANDLE_TYPE_DESCRIPTOR_SET);
+VK_DEFINE_NONDISP_HANDLE (VkDynamicViewportState, HANDLE_TYPE_DYNAMIC_VIEWPORT_STATE);
+VK_DEFINE_NONDISP_HANDLE (VkDynamicRasterState, HANDLE_TYPE_DYNAMIC_RASTER_STATE);
+VK_DEFINE_NONDISP_HANDLE (VkDynamicColorBlendState, HANDLE_TYPE_DYNAMIC_COLOR_BLEND_STATE);
+VK_DEFINE_NONDISP_HANDLE (VkDynamicDepthStencilState, HANDLE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE);
+VK_DEFINE_NONDISP_HANDLE (VkFramebuffer, HANDLE_TYPE_FRAMEBUFFER);
+VK_DEFINE_NONDISP_HANDLE (VkCmdPool, HANDLE_TYPE_CMD_POOL);
-VK_DEFINE_BASE_HANDLE (VkObject);
-VK_DEFINE_DISP_SUBCLASS_HANDLE (VkInstance, VkObject);
-VK_DEFINE_DISP_SUBCLASS_HANDLE (VkPhysicalDevice, VkObject);
-VK_DEFINE_DISP_SUBCLASS_HANDLE (VkDevice, VkObject);
-VK_DEFINE_DISP_SUBCLASS_HANDLE (VkQueue, VkObject);
-VK_DEFINE_DISP_SUBCLASS_HANDLE (VkCmdBuffer, VkObject);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkNonDispatchable, VkObject);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDeviceMemory, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkBuffer, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkBufferView, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkImage, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkImageView, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkColorAttachmentView, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDepthStencilView, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkShader, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkPipeline, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkPipelineLayout, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkSampler, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDescriptorSet, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDescriptorSetLayout, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDescriptorPool, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicStateObject, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicVpState, VkDynamicStateObject);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicRsState, VkDynamicStateObject);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicCbState, VkDynamicStateObject);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkDynamicDsState, VkDynamicStateObject);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkFence, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkSemaphore, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkEvent, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkQueryPool, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkFramebuffer, VkNonDispatchable);
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE (VkRenderPass, VkNonDispatchable);
-
-enum VkMemoryPriority
-{
- VK_MEMORY_PRIORITY_UNUSED = 0x00000000,
- VK_MEMORY_PRIORITY_VERY_LOW = 0x00000001,
- VK_MEMORY_PRIORITY_LOW = 0x00000002,
- VK_MEMORY_PRIORITY_NORMAL = 0x00000003,
- VK_MEMORY_PRIORITY_HIGH = 0x00000004,
- VK_MEMORY_PRIORITY_VERY_HIGH = 0x00000005,
-};
-
-enum VkImageLayout
-{
- VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000,
- VK_IMAGE_LAYOUT_GENERAL = 0x00000001,
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002,
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003,
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004,
- VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005,
- VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006,
- VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007,
- VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008,
-};
-
-enum VkPipeEvent
+enum VkResult
{
- VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001,
- VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002,
- VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003,
- VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004,
- VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005,
- VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006,
- VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007,
- VK_PIPE_EVENT_COMMANDS_COMPLETE = 0x00000008,
+ 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,
};
-enum VkWaitEvent
+enum VkStructureType
{
- VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001,
- VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002,
+ 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_LAYER_CREATE_INFO = 35,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42,
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44,
+ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46,
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47,
+ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49,
+ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 50,
};
-enum VkAttachmentLoadOp
+enum VkSystemAllocType
{
- VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000,
- VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001,
- VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002,
+ 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,
};
-enum VkAttachmentStoreOp
+enum VkFormat
{
- VK_ATTACHMENT_STORE_OP_STORE = 0x00000000,
- VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001,
- VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002,
+ 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,
};
enum VkImageType
{
- VK_IMAGE_TYPE_1D = 0x00000000,
- VK_IMAGE_TYPE_2D = 0x00000001,
- VK_IMAGE_TYPE_3D = 0x00000002,
+ VK_IMAGE_TYPE_1D = 0,
+ VK_IMAGE_TYPE_2D = 1,
+ VK_IMAGE_TYPE_3D = 2,
};
enum VkImageTiling
{
- VK_IMAGE_TILING_LINEAR = 0x00000000,
- VK_IMAGE_TILING_OPTIMAL = 0x00000001,
+ VK_IMAGE_TILING_LINEAR = 0,
+ VK_IMAGE_TILING_OPTIMAL = 1,
};
-enum VkImageViewType
+enum VkPhysicalDeviceType
{
- VK_IMAGE_VIEW_TYPE_1D = 0x00000000,
- VK_IMAGE_VIEW_TYPE_2D = 0x00000001,
- VK_IMAGE_VIEW_TYPE_3D = 0x00000002,
- VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003,
+ 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,
};
enum VkImageAspect
{
- VK_IMAGE_ASPECT_COLOR = 0x00000000,
- VK_IMAGE_ASPECT_DEPTH = 0x00000001,
- VK_IMAGE_ASPECT_STENCIL = 0x00000002,
-};
-
-enum VkBufferViewType
-{
- VK_BUFFER_VIEW_TYPE_RAW = 0x00000000,
- VK_BUFFER_VIEW_TYPE_FORMATTED = 0x00000001,
-};
-
-enum VkChannelSwizzle
-{
- VK_CHANNEL_SWIZZLE_ZERO = 0x00000000,
- VK_CHANNEL_SWIZZLE_ONE = 0x00000001,
- VK_CHANNEL_SWIZZLE_R = 0x00000002,
- VK_CHANNEL_SWIZZLE_G = 0x00000003,
- VK_CHANNEL_SWIZZLE_B = 0x00000004,
- VK_CHANNEL_SWIZZLE_A = 0x00000005,
+ VK_IMAGE_ASPECT_COLOR = 0,
+ VK_IMAGE_ASPECT_DEPTH = 1,
+ VK_IMAGE_ASPECT_STENCIL = 2,
+ VK_IMAGE_ASPECT_METADATA = 3,
};
-enum VkDescriptorType
+enum VkQueryType
{
- VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000,
- VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001,
- VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002,
- VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003,
- VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004,
- VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005,
- VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006,
- VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007,
- VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008,
- VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009,
+ VK_QUERY_TYPE_OCCLUSION = 0,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
};
-enum VkDescriptorPoolUsage
+enum VkSharingMode
{
- VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000,
- VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001,
+ VK_SHARING_MODE_EXCLUSIVE = 0,
+ VK_SHARING_MODE_CONCURRENT = 1,
};
-enum VkDescriptorUpdateMode
+enum VkBufferViewType
{
- VK_DESCRIPTOR_UPDATE_MODE_COPY = 0x00000000,
- VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001,
+ VK_BUFFER_VIEW_TYPE_RAW = 0,
+ VK_BUFFER_VIEW_TYPE_FORMATTED = 1,
};
-enum VkDescriptorSetUsage
+enum VkImageViewType
{
- VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000,
- VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001,
+ 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,
};
-enum VkQueryType
+enum VkChannelSwizzle
{
- VK_QUERY_TYPE_OCCLUSION = 0x00000000,
- VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001,
+ 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,
};
-enum VkTimestampType
+enum VkShaderStage
{
- VK_TIMESTAMP_TYPE_TOP = 0x00000000,
- VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001,
+ 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,
};
-enum VkBorderColor
+enum VkVertexInputStepRate
{
- VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000,
- VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001,
- VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002,
+ VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
+ VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
};
-enum VkPipelineBindPoint
+enum VkPrimitiveTopology
{
- VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
- VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
+ 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,
};
-enum VkStateBindPoint
+enum VkFillMode
{
- VK_STATE_BIND_POINT_VIEWPORT = 0x00000000,
- VK_STATE_BIND_POINT_RASTER = 0x00000001,
- VK_STATE_BIND_POINT_COLOR_BLEND = 0x00000002,
- VK_STATE_BIND_POINT_DEPTH_STENCIL = 0x00000003,
+ VK_FILL_MODE_POINTS = 0,
+ VK_FILL_MODE_WIREFRAME = 1,
+ VK_FILL_MODE_SOLID = 2,
};
-enum VkPrimitiveTopology
+enum VkCullMode
{
- VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000,
- VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001,
- VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
- VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006,
- VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009,
- VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a,
+ VK_CULL_MODE_NONE = 0,
+ VK_CULL_MODE_FRONT = 1,
+ VK_CULL_MODE_BACK = 2,
+ VK_CULL_MODE_FRONT_AND_BACK = 3,
};
-enum VkIndexType
+enum VkFrontFace
{
- VK_INDEX_TYPE_UINT8 = 0x00000000,
- VK_INDEX_TYPE_UINT16 = 0x00000001,
- VK_INDEX_TYPE_UINT32 = 0x00000002,
+ VK_FRONT_FACE_CCW = 0,
+ VK_FRONT_FACE_CW = 1,
};
-enum VkTexFilter
+enum VkCompareOp
{
- VK_TEX_FILTER_NEAREST = 0x00000000,
- VK_TEX_FILTER_LINEAR = 0x00000001,
+ 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,
};
-enum VkTexMipmapMode
+enum VkStencilOp
{
- VK_TEX_MIPMAP_MODE_BASE = 0x00000000,
- VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001,
- VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002,
+ 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,
};
-enum VkTexAddress
+enum VkLogicOp
{
- VK_TEX_ADDRESS_WRAP = 0x00000000,
- VK_TEX_ADDRESS_MIRROR = 0x00000001,
- VK_TEX_ADDRESS_CLAMP = 0x00000002,
- VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003,
- VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004,
+ 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,
};
-enum VkCompareOp
+enum VkBlend
{
- VK_COMPARE_OP_NEVER = 0x00000000,
- VK_COMPARE_OP_LESS = 0x00000001,
- VK_COMPARE_OP_EQUAL = 0x00000002,
- VK_COMPARE_OP_LESS_EQUAL = 0x00000003,
- VK_COMPARE_OP_GREATER = 0x00000004,
- VK_COMPARE_OP_NOT_EQUAL = 0x00000005,
- VK_COMPARE_OP_GREATER_EQUAL = 0x00000006,
- VK_COMPARE_OP_ALWAYS = 0x00000007,
+ 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,
};
-enum VkFillMode
+enum VkBlendOp
{
- VK_FILL_MODE_POINTS = 0x00000000,
- VK_FILL_MODE_WIREFRAME = 0x00000001,
- VK_FILL_MODE_SOLID = 0x00000002,
+ 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,
};
-enum VkCullMode
+enum VkTexFilter
{
- VK_CULL_MODE_NONE = 0x00000000,
- VK_CULL_MODE_FRONT = 0x00000001,
- VK_CULL_MODE_BACK = 0x00000002,
- VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
+ VK_TEX_FILTER_NEAREST = 0,
+ VK_TEX_FILTER_LINEAR = 1,
};
-enum VkFrontFace
+enum VkTexMipmapMode
{
- VK_FRONT_FACE_CCW = 0x00000000,
- VK_FRONT_FACE_CW = 0x00000001,
+ VK_TEX_MIPMAP_MODE_BASE = 0,
+ VK_TEX_MIPMAP_MODE_NEAREST = 1,
+ VK_TEX_MIPMAP_MODE_LINEAR = 2,
};
-enum VkProvokingVertex
+enum VkTexAddress
{
- VK_PROVOKING_VERTEX_FIRST = 0x00000000,
- VK_PROVOKING_VERTEX_LAST = 0x00000001,
+ 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,
};
-enum VkCoordinateOrigin
+enum VkBorderColor
{
- VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
- VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
+ 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,
};
-enum VkDepthMode
+enum VkDescriptorType
{
- VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000,
- VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001,
+ 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,
};
-enum VkBlend
+enum VkDescriptorPoolUsage
{
- VK_BLEND_ZERO = 0x00000000,
- VK_BLEND_ONE = 0x00000001,
- VK_BLEND_SRC_COLOR = 0x00000002,
- VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
- VK_BLEND_DEST_COLOR = 0x00000004,
- VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
- VK_BLEND_SRC_ALPHA = 0x00000006,
- VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
- VK_BLEND_DEST_ALPHA = 0x00000008,
- VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
- VK_BLEND_CONSTANT_COLOR = 0x0000000a,
- VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
- VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
- VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
- VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
- VK_BLEND_SRC1_COLOR = 0x0000000f,
- VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
- VK_BLEND_SRC1_ALPHA = 0x00000011,
- VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
+ VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0,
+ VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1,
};
-enum VkBlendOp
+enum VkDescriptorSetUsage
{
- VK_BLEND_OP_ADD = 0x00000000,
- VK_BLEND_OP_SUBTRACT = 0x00000001,
- VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002,
- VK_BLEND_OP_MIN = 0x00000003,
- VK_BLEND_OP_MAX = 0x00000004,
+ VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0,
+ VK_DESCRIPTOR_SET_USAGE_STATIC = 1,
};
-enum VkStencilOp
+enum VkImageLayout
{
- VK_STENCIL_OP_KEEP = 0x00000000,
- VK_STENCIL_OP_ZERO = 0x00000001,
- VK_STENCIL_OP_REPLACE = 0x00000002,
- VK_STENCIL_OP_INC_CLAMP = 0x00000003,
- VK_STENCIL_OP_DEC_CLAMP = 0x00000004,
- VK_STENCIL_OP_INVERT = 0x00000005,
- VK_STENCIL_OP_INC_WRAP = 0x00000006,
- VK_STENCIL_OP_DEC_WRAP = 0x00000007,
+ 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,
};
-enum VkLogicOp
+enum VkAttachmentLoadOp
{
- VK_LOGIC_OP_COPY = 0x00000000,
- VK_LOGIC_OP_CLEAR = 0x00000001,
- VK_LOGIC_OP_AND = 0x00000002,
- VK_LOGIC_OP_AND_REVERSE = 0x00000003,
- VK_LOGIC_OP_AND_INVERTED = 0x00000004,
- VK_LOGIC_OP_NOOP = 0x00000005,
- VK_LOGIC_OP_XOR = 0x00000006,
- VK_LOGIC_OP_OR = 0x00000007,
- VK_LOGIC_OP_NOR = 0x00000008,
- VK_LOGIC_OP_EQUIV = 0x00000009,
- VK_LOGIC_OP_INVERT = 0x0000000a,
- VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
- VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
- VK_LOGIC_OP_OR_INVERTED = 0x0000000d,
- VK_LOGIC_OP_NAND = 0x0000000e,
- VK_LOGIC_OP_SET = 0x0000000f,
+ VK_ATTACHMENT_LOAD_OP_LOAD = 0,
+ VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
};
-enum VkSystemAllocType
+enum VkAttachmentStoreOp
{
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002,
- VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003,
- VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004,
+ VK_ATTACHMENT_STORE_OP_STORE = 0,
+ VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
};
-enum VkPhysicalDeviceType
+enum VkPipelineBindPoint
{
- VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000,
- VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001,
- VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002,
- VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003,
- VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004,
+ VK_PIPELINE_BIND_POINT_COMPUTE = 0,
+ VK_PIPELINE_BIND_POINT_GRAPHICS = 1,
};
-enum VkPhysicalDeviceInfoType
+enum VkCmdBufferLevel
{
- VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES = 0x00000000,
- VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE = 0x00000001,
- VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES = 0x00000002,
- VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES = 0x00000003,
+ VK_CMD_BUFFER_LEVEL_PRIMARY = 0,
+ VK_CMD_BUFFER_LEVEL_SECONDARY = 1,
};
-enum VkExtensionInfoType
+enum VkIndexType
{
- VK_EXTENSION_INFO_TYPE_COUNT = 0x00000000,
- VK_EXTENSION_INFO_TYPE_PROPERTIES = 0x00000001,
+ VK_INDEX_TYPE_UINT16 = 0,
+ VK_INDEX_TYPE_UINT32 = 1,
};
-enum VkFormatInfoType
+enum VkTimestampType
{
- VK_FORMAT_INFO_TYPE_PROPERTIES = 0x00000000,
+ VK_TIMESTAMP_TYPE_TOP = 0,
+ VK_TIMESTAMP_TYPE_BOTTOM = 1,
};
-enum VkSubresourceInfoType
+enum VkRenderPassContents
{
- VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000,
+ VK_RENDER_PASS_CONTENTS_INLINE = 0,
+ VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
};
-enum VkObjectInfoType
+enum VkFormatFeatureFlagBits
{
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000,
- VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001,
+ 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,
};
+typedef deUint32 VkFormatFeatureFlags;
-enum VkVertexInputStepRate
+enum VkImageUsageFlagBits
{
- VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
- VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
- VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2,
+ 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,
};
+typedef deUint32 VkImageUsageFlags;
-enum VkFormat
+enum VkQueueFlagBits
{
- VK_FORMAT_UNDEFINED = 0x00000000,
- VK_FORMAT_R4G4_UNORM = 0x00000001,
- VK_FORMAT_R4G4_USCALED = 0x00000002,
- VK_FORMAT_R4G4B4A4_UNORM = 0x00000003,
- VK_FORMAT_R4G4B4A4_USCALED = 0x00000004,
- VK_FORMAT_R5G6B5_UNORM = 0x00000005,
- VK_FORMAT_R5G6B5_USCALED = 0x00000006,
- VK_FORMAT_R5G5B5A1_UNORM = 0x00000007,
- VK_FORMAT_R5G5B5A1_USCALED = 0x00000008,
- VK_FORMAT_R8_UNORM = 0x00000009,
- VK_FORMAT_R8_SNORM = 0x0000000A,
- VK_FORMAT_R8_USCALED = 0x0000000B,
- VK_FORMAT_R8_SSCALED = 0x0000000C,
- VK_FORMAT_R8_UINT = 0x0000000D,
- VK_FORMAT_R8_SINT = 0x0000000E,
- VK_FORMAT_R8_SRGB = 0x0000000F,
- VK_FORMAT_R8G8_UNORM = 0x00000010,
- VK_FORMAT_R8G8_SNORM = 0x00000011,
- VK_FORMAT_R8G8_USCALED = 0x00000012,
- VK_FORMAT_R8G8_SSCALED = 0x00000013,
- VK_FORMAT_R8G8_UINT = 0x00000014,
- VK_FORMAT_R8G8_SINT = 0x00000015,
- VK_FORMAT_R8G8_SRGB = 0x00000016,
- VK_FORMAT_R8G8B8_UNORM = 0x00000017,
- VK_FORMAT_R8G8B8_SNORM = 0x00000018,
- VK_FORMAT_R8G8B8_USCALED = 0x00000019,
- VK_FORMAT_R8G8B8_SSCALED = 0x0000001A,
- VK_FORMAT_R8G8B8_UINT = 0x0000001B,
- VK_FORMAT_R8G8B8_SINT = 0x0000001C,
- VK_FORMAT_R8G8B8_SRGB = 0x0000001D,
- VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E,
- VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F,
- VK_FORMAT_R8G8B8A8_USCALED = 0x00000020,
- VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021,
- VK_FORMAT_R8G8B8A8_UINT = 0x00000022,
- VK_FORMAT_R8G8B8A8_SINT = 0x00000023,
- VK_FORMAT_R8G8B8A8_SRGB = 0x00000024,
- VK_FORMAT_R10G10B10A2_UNORM = 0x00000025,
- VK_FORMAT_R10G10B10A2_SNORM = 0x00000026,
- VK_FORMAT_R10G10B10A2_USCALED = 0x00000027,
- VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028,
- VK_FORMAT_R10G10B10A2_UINT = 0x00000029,
- VK_FORMAT_R10G10B10A2_SINT = 0x0000002A,
- VK_FORMAT_R16_UNORM = 0x0000002B,
- VK_FORMAT_R16_SNORM = 0x0000002C,
- VK_FORMAT_R16_USCALED = 0x0000002D,
- VK_FORMAT_R16_SSCALED = 0x0000002E,
- VK_FORMAT_R16_UINT = 0x0000002F,
- VK_FORMAT_R16_SINT = 0x00000030,
- VK_FORMAT_R16_SFLOAT = 0x00000031,
- VK_FORMAT_R16G16_UNORM = 0x00000032,
- VK_FORMAT_R16G16_SNORM = 0x00000033,
- VK_FORMAT_R16G16_USCALED = 0x00000034,
- VK_FORMAT_R16G16_SSCALED = 0x00000035,
- VK_FORMAT_R16G16_UINT = 0x00000036,
- VK_FORMAT_R16G16_SINT = 0x00000037,
- VK_FORMAT_R16G16_SFLOAT = 0x00000038,
- VK_FORMAT_R16G16B16_UNORM = 0x00000039,
- VK_FORMAT_R16G16B16_SNORM = 0x0000003A,
- VK_FORMAT_R16G16B16_USCALED = 0x0000003B,
- VK_FORMAT_R16G16B16_SSCALED = 0x0000003C,
- VK_FORMAT_R16G16B16_UINT = 0x0000003D,
- VK_FORMAT_R16G16B16_SINT = 0x0000003E,
- VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F,
- VK_FORMAT_R16G16B16A16_UNORM = 0x00000040,
- VK_FORMAT_R16G16B16A16_SNORM = 0x00000041,
- VK_FORMAT_R16G16B16A16_USCALED = 0x00000042,
- VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043,
- VK_FORMAT_R16G16B16A16_UINT = 0x00000044,
- VK_FORMAT_R16G16B16A16_SINT = 0x00000045,
- VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046,
- VK_FORMAT_R32_UINT = 0x00000047,
- VK_FORMAT_R32_SINT = 0x00000048,
- VK_FORMAT_R32_SFLOAT = 0x00000049,
- VK_FORMAT_R32G32_UINT = 0x0000004A,
- VK_FORMAT_R32G32_SINT = 0x0000004B,
- VK_FORMAT_R32G32_SFLOAT = 0x0000004C,
- VK_FORMAT_R32G32B32_UINT = 0x0000004D,
- VK_FORMAT_R32G32B32_SINT = 0x0000004E,
- VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F,
- VK_FORMAT_R32G32B32A32_UINT = 0x00000050,
- VK_FORMAT_R32G32B32A32_SINT = 0x00000051,
- VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052,
- VK_FORMAT_R64_SFLOAT = 0x00000053,
- VK_FORMAT_R64G64_SFLOAT = 0x00000054,
- VK_FORMAT_R64G64B64_SFLOAT = 0x00000055,
- VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056,
- VK_FORMAT_R11G11B10_UFLOAT = 0x00000057,
- VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058,
- VK_FORMAT_D16_UNORM = 0x00000059,
- VK_FORMAT_D24_UNORM = 0x0000005A,
- VK_FORMAT_D32_SFLOAT = 0x0000005B,
- VK_FORMAT_S8_UINT = 0x0000005C,
- VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D,
- VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E,
- VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F,
- VK_FORMAT_BC1_RGB_UNORM = 0x00000060,
- VK_FORMAT_BC1_RGB_SRGB = 0x00000061,
- VK_FORMAT_BC1_RGBA_UNORM = 0x00000062,
- VK_FORMAT_BC1_RGBA_SRGB = 0x00000063,
- VK_FORMAT_BC2_UNORM = 0x00000064,
- VK_FORMAT_BC2_SRGB = 0x00000065,
- VK_FORMAT_BC3_UNORM = 0x00000066,
- VK_FORMAT_BC3_SRGB = 0x00000067,
- VK_FORMAT_BC4_UNORM = 0x00000068,
- VK_FORMAT_BC4_SNORM = 0x00000069,
- VK_FORMAT_BC5_UNORM = 0x0000006A,
- VK_FORMAT_BC5_SNORM = 0x0000006B,
- VK_FORMAT_BC6H_UFLOAT = 0x0000006C,
- VK_FORMAT_BC6H_SFLOAT = 0x0000006D,
- VK_FORMAT_BC7_UNORM = 0x0000006E,
- VK_FORMAT_BC7_SRGB = 0x0000006F,
- VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070,
- VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071,
- VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072,
- VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073,
- VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074,
- VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075,
- VK_FORMAT_EAC_R11_UNORM = 0x00000076,
- VK_FORMAT_EAC_R11_SNORM = 0x00000077,
- VK_FORMAT_EAC_R11G11_UNORM = 0x00000078,
- VK_FORMAT_EAC_R11G11_SNORM = 0x00000079,
- VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A,
- VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B,
- VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C,
- VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D,
- VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E,
- VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F,
- VK_FORMAT_ASTC_6x5_UNORM = 0x00000080,
- VK_FORMAT_ASTC_6x5_SRGB = 0x00000081,
- VK_FORMAT_ASTC_6x6_UNORM = 0x00000082,
- VK_FORMAT_ASTC_6x6_SRGB = 0x00000083,
- VK_FORMAT_ASTC_8x5_UNORM = 0x00000084,
- VK_FORMAT_ASTC_8x5_SRGB = 0x00000085,
- VK_FORMAT_ASTC_8x6_UNORM = 0x00000086,
- VK_FORMAT_ASTC_8x6_SRGB = 0x00000087,
- VK_FORMAT_ASTC_8x8_UNORM = 0x00000088,
- VK_FORMAT_ASTC_8x8_SRGB = 0x00000089,
- VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A,
- VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B,
- VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C,
- VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D,
- VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E,
- VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F,
- VK_FORMAT_ASTC_10x10_UNORM = 0x00000090,
- VK_FORMAT_ASTC_10x10_SRGB = 0x00000091,
- VK_FORMAT_ASTC_12x10_UNORM = 0x00000092,
- VK_FORMAT_ASTC_12x10_SRGB = 0x00000093,
- VK_FORMAT_ASTC_12x12_UNORM = 0x00000094,
- VK_FORMAT_ASTC_12x12_SRGB = 0x00000095,
- VK_FORMAT_B4G4R4A4_UNORM = 0x00000096,
- VK_FORMAT_B5G5R5A1_UNORM = 0x00000097,
- VK_FORMAT_B5G6R5_UNORM = 0x00000098,
- VK_FORMAT_B5G6R5_USCALED = 0x00000099,
- VK_FORMAT_B8G8R8_UNORM = 0x0000009A,
- VK_FORMAT_B8G8R8_SNORM = 0x0000009B,
- VK_FORMAT_B8G8R8_USCALED = 0x0000009C,
- VK_FORMAT_B8G8R8_SSCALED = 0x0000009D,
- VK_FORMAT_B8G8R8_UINT = 0x0000009E,
- VK_FORMAT_B8G8R8_SINT = 0x0000009F,
- VK_FORMAT_B8G8R8_SRGB = 0x000000A0,
- VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1,
- VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2,
- VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3,
- VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4,
- VK_FORMAT_B8G8R8A8_UINT = 0x000000A5,
- VK_FORMAT_B8G8R8A8_SINT = 0x000000A6,
- VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7,
- VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8,
- VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9,
- VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA,
- VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB,
- VK_FORMAT_B10G10R10A2_UINT = 0x000000AC,
- VK_FORMAT_B10G10R10A2_SINT = 0x000000AD,
+ 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,
};
+typedef deUint32 VkQueueFlags;
-enum VkShaderStage
+enum VkMemoryPropertyFlagBits
{
- 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_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,
};
+typedef deUint32 VkMemoryPropertyFlags;
-enum VkStructureType
+enum VkMemoryHeapFlagBits
{
- VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
- VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
- VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 3,
- VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 4,
- VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 5,
- VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 6,
- VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 7,
- VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 8,
- VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 9,
- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 10,
- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 11,
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 12,
- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 13,
- VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 14,
- VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 15,
- VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 16,
- VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 17,
- VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 18,
- VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 19,
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 20,
- VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 21,
- VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 22,
- VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 23,
- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 24,
- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 25,
- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 26,
- VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 27,
- VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 28,
- VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 29,
- VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 30,
- VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 31,
- VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 32,
- VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 33,
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 34,
- VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 35,
- VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 36,
- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 38,
- VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 39,
- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 40,
- VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 41,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 42,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 45,
- VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 46,
- VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 47,
- VK_STRUCTURE_TYPE_UPDATE_IMAGES = 48,
- VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 49,
- VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 50,
- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 51,
- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 52,
-};
-
-enum VkObjectType
-{
- VK_OBJECT_TYPE_INSTANCE = 0,
- VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1,
- VK_OBJECT_TYPE_DEVICE = 2,
- VK_OBJECT_TYPE_QUEUE = 3,
- VK_OBJECT_TYPE_COMMAND_BUFFER = 4,
- VK_OBJECT_TYPE_DEVICE_MEMORY = 5,
- VK_OBJECT_TYPE_BUFFER = 6,
- VK_OBJECT_TYPE_BUFFER_VIEW = 7,
- VK_OBJECT_TYPE_IMAGE = 8,
- VK_OBJECT_TYPE_IMAGE_VIEW = 9,
- VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10,
- VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11,
- VK_OBJECT_TYPE_SHADER = 12,
- VK_OBJECT_TYPE_PIPELINE = 13,
- VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14,
- VK_OBJECT_TYPE_SAMPLER = 15,
- VK_OBJECT_TYPE_DESCRIPTOR_SET = 16,
- VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17,
- VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18,
- VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19,
- VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20,
- VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21,
- VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22,
- VK_OBJECT_TYPE_FENCE = 23,
- VK_OBJECT_TYPE_SEMAPHORE = 24,
- VK_OBJECT_TYPE_EVENT = 25,
- VK_OBJECT_TYPE_QUERY_POOL = 26,
- VK_OBJECT_TYPE_FRAMEBUFFER = 27,
- VK_OBJECT_TYPE_RENDER_PASS = 28,
+ VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001,
};
+typedef deUint32 VkMemoryHeapFlags;
-enum VkResult
+enum VkDeviceCreateFlagBits
{
- VK_SUCCESS = 0x0000000,
- VK_UNSUPPORTED = 0x0000001,
- VK_NOT_READY = 0x0000002,
- VK_TIMEOUT = 0x0000003,
- VK_EVENT_SET = 0x0000004,
- VK_EVENT_RESET = 0x0000005,
- VK_ERROR_UNKNOWN = -(0x00000001),
- VK_ERROR_UNAVAILABLE = -(0x00000002),
- VK_ERROR_INITIALIZATION_FAILED = -(0x00000003),
- VK_ERROR_OUT_OF_HOST_MEMORY = -(0x00000004),
- VK_ERROR_OUT_OF_DEVICE_MEMORY = -(0x00000005),
- VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006),
- VK_ERROR_DEVICE_LOST = -(0x00000007),
- VK_ERROR_INVALID_POINTER = -(0x00000008),
- VK_ERROR_INVALID_VALUE = -(0x00000009),
- VK_ERROR_INVALID_HANDLE = -(0x0000000A),
- VK_ERROR_INVALID_ORDINAL = -(0x0000000B),
- VK_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C),
- VK_ERROR_INVALID_EXTENSION = -(0x0000000D),
- VK_ERROR_INVALID_FLAGS = -(0x0000000E),
- VK_ERROR_INVALID_ALIGNMENT = -(0x0000000F),
- VK_ERROR_INVALID_FORMAT = -(0x00000010),
- VK_ERROR_INVALID_IMAGE = -(0x00000011),
- VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012),
- VK_ERROR_INVALID_QUEUE_TYPE = -(0x00000013),
- VK_ERROR_INVALID_OBJECT_TYPE = -(0x00000014),
- VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015),
- VK_ERROR_BAD_SHADER_CODE = -(0x00000016),
- VK_ERROR_BAD_PIPELINE_DATA = -(0x00000017),
- VK_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018),
- VK_ERROR_NOT_MAPPABLE = -(0x00000019),
- VK_ERROR_MEMORY_MAP_FAILED = -(0x0000001A),
- VK_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B),
- VK_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C),
- VK_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D),
- VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E),
- VK_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F),
- VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020),
- VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021),
- VK_ERROR_NOT_SHAREABLE = -(0x00000022),
+ VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
};
+typedef deUint32 VkDeviceCreateFlags;
-enum VkDeviceCreateFlagBits
+enum VkSparseImageFormatFlagBits
{
- VK_DEVICE_CREATE_VALIDATION_BIT = VK_BIT(0),
- VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = VK_BIT(1),
+ 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,
};
-typedef deUint32 VkDeviceCreateFlags;
+typedef deUint32 VkSparseImageFormatFlags;
-enum VkQueueFlagBits
+enum VkSparseMemoryBindFlagBits
{
- VK_QUEUE_GRAPHICS_BIT = VK_BIT(0),
- VK_QUEUE_COMPUTE_BIT = VK_BIT(1),
- VK_QUEUE_DMA_BIT = VK_BIT(2),
- VK_QUEUE_MEMMGR_BIT = VK_BIT(3),
- VK_QUEUE_EXTENDED_BIT = VK_BIT(30),
+ VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001,
};
-typedef deUint32 VkQueueFlags;
+typedef deUint32 VkSparseMemoryBindFlags;
-enum VkMemoryPropertyFlagBits
+enum VkFenceCreateFlagBits
{
- VK_MEMORY_PROPERTY_DEVICE_ONLY = 0,
- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VK_BIT(0),
- VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = VK_BIT(1),
- VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = VK_BIT(2),
- VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = VK_BIT(3),
- VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = VK_BIT(4),
- VK_MEMORY_PROPERTY_SHAREABLE_BIT = VK_BIT(5),
+ VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
};
-typedef deUint32 VkMemoryPropertyFlags;
+typedef deUint32 VkFenceCreateFlags;
-enum VkMemoryOutputFlagBits
+enum VkQueryPipelineStatisticFlagBits
{
- VK_MEMORY_OUTPUT_CPU_WRITE_BIT = VK_BIT(0),
- VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = VK_BIT(1),
- VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = VK_BIT(2),
- VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(3),
- VK_MEMORY_OUTPUT_TRANSFER_BIT = VK_BIT(4),
+ 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,
};
-typedef deUint32 VkMemoryOutputFlags;
+typedef deUint32 VkQueryPipelineStatisticFlags;
-enum VkMemoryInputFlagBits
+enum VkQueryResultFlagBits
{
- VK_MEMORY_INPUT_CPU_READ_BIT = VK_BIT(0),
- VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = VK_BIT(1),
- VK_MEMORY_INPUT_INDEX_FETCH_BIT = VK_BIT(2),
- VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = VK_BIT(3),
- VK_MEMORY_INPUT_UNIFORM_READ_BIT = VK_BIT(4),
- VK_MEMORY_INPUT_SHADER_READ_BIT = VK_BIT(5),
- VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = VK_BIT(6),
- VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(7),
- VK_MEMORY_INPUT_TRANSFER_BIT = VK_BIT(8),
+ 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,
};
-typedef deUint32 VkMemoryInputFlags;
+typedef deUint32 VkQueryResultFlags;
enum VkBufferUsageFlagBits
{
VK_BUFFER_USAGE_GENERAL = 0,
- VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0),
- VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1),
- VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(2),
- VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(3),
- VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VK_BIT(4),
- VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VK_BIT(5),
- VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VK_BIT(6),
- VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VK_BIT(7),
- VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VK_BIT(8),
+ 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,
};
typedef deUint32 VkBufferUsageFlags;
enum VkBufferCreateFlagBits
{
- VK_BUFFER_CREATE_SHAREABLE_BIT = VK_BIT(0),
- VK_BUFFER_CREATE_SPARSE_BIT = VK_BIT(1),
+ VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001,
+ VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
};
typedef deUint32 VkBufferCreateFlags;
-enum VkShaderStageFlagBits
-{
- VK_SHADER_STAGE_VERTEX_BIT = VK_BIT(0),
- VK_SHADER_STAGE_TESS_CONTROL_BIT = VK_BIT(1),
- VK_SHADER_STAGE_TESS_EVALUATION_BIT = VK_BIT(2),
- VK_SHADER_STAGE_GEOMETRY_BIT = VK_BIT(3),
- VK_SHADER_STAGE_FRAGMENT_BIT = VK_BIT(4),
- VK_SHADER_STAGE_COMPUTE_BIT = VK_BIT(5),
- VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
-};
-typedef deUint32 VkShaderStageFlags;
-
-enum VkImageUsageFlagBits
+enum VkImageCreateFlagBits
{
- VK_IMAGE_USAGE_GENERAL = 0,
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0),
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1),
- VK_IMAGE_USAGE_SAMPLED_BIT = VK_BIT(2),
- VK_IMAGE_USAGE_STORAGE_BIT = VK_BIT(3),
- VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VK_BIT(4),
- VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = VK_BIT(5),
- VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VK_BIT(6),
+ 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,
};
-typedef deUint32 VkImageUsageFlags;
+typedef deUint32 VkImageCreateFlags;
-enum VkImageCreateFlagBits
+enum VkAttachmentViewCreateFlagBits
{
- VK_IMAGE_CREATE_INVARIANT_DATA_BIT = VK_BIT(0),
- VK_IMAGE_CREATE_CLONEABLE_BIT = VK_BIT(1),
- VK_IMAGE_CREATE_SHAREABLE_BIT = VK_BIT(2),
- VK_IMAGE_CREATE_SPARSE_BIT = VK_BIT(3),
- VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VK_BIT(4),
- VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VK_BIT(5),
+ VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+ VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
};
-typedef deUint32 VkImageCreateFlags;
+typedef deUint32 VkAttachmentViewCreateFlags;
-enum VkDepthStencilViewCreateFlagBits
+enum VkChannelFlagBits
{
- VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = VK_BIT(0),
- VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = VK_BIT(1),
+ VK_CHANNEL_R_BIT = 0x00000001,
+ VK_CHANNEL_G_BIT = 0x00000002,
+ VK_CHANNEL_B_BIT = 0x00000004,
+ VK_CHANNEL_A_BIT = 0x00000008,
};
-typedef deUint32 VkDepthStencilViewCreateFlags;
+typedef deUint32 VkChannelFlags;
enum VkPipelineCreateFlagBits
{
- VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0),
- VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1),
+ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
};
typedef deUint32 VkPipelineCreateFlags;
-enum VkChannelFlagBits
+enum VkShaderStageFlagBits
{
- VK_CHANNEL_R_BIT = VK_BIT(0),
- VK_CHANNEL_G_BIT = VK_BIT(1),
- VK_CHANNEL_B_BIT = VK_BIT(2),
- VK_CHANNEL_A_BIT = VK_BIT(3),
+ 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,
};
-typedef deUint32 VkChannelFlags;
+typedef deUint32 VkShaderStageFlags;
-enum VkFenceCreateFlagBits
+enum VkSubpassDescriptionFlagBits
{
- VK_FENCE_CREATE_SIGNALED_BIT = VK_BIT(0),
+ VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001,
};
-typedef deUint32 VkFenceCreateFlags;
+typedef deUint32 VkSubpassDescriptionFlags;
-enum VkSemaphoreCreateFlagBits
+enum VkPipelineStageFlagBits
{
- VK_SEMAPHORE_CREATE_SHAREABLE_BIT = VK_BIT(0),
+ 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,
};
-typedef deUint32 VkSemaphoreCreateFlags;
+typedef deUint32 VkPipelineStageFlags;
-enum VkFormatFeatureFlagBits
+enum VkMemoryOutputFlagBits
{
- VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VK_BIT(0),
- VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VK_BIT(1),
- VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VK_BIT(2),
- VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(3),
- VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(4),
- VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VK_BIT(5),
- VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VK_BIT(6),
- VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VK_BIT(7),
- VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VK_BIT(8),
- VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(9),
- VK_FORMAT_FEATURE_CONVERSION_BIT = VK_BIT(10),
+ 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,
};
-typedef deUint32 VkFormatFeatureFlags;
+typedef deUint32 VkMemoryOutputFlags;
-enum VkQueryControlFlagBits
+enum VkMemoryInputFlagBits
{
- VK_QUERY_CONTROL_CONSERVATIVE_BIT = VK_BIT(0),
+ 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,
};
-typedef deUint32 VkQueryControlFlags;
+typedef deUint32 VkMemoryInputFlags;
-enum VkQueryResultFlagBits
+enum VkCmdPoolCreateFlagBits
{
- VK_QUERY_RESULT_32_BIT = 0,
- VK_QUERY_RESULT_64_BIT = VK_BIT(0),
- VK_QUERY_RESULT_NO_WAIT_BIT = 0,
- VK_QUERY_RESULT_WAIT_BIT = VK_BIT(1),
- VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VK_BIT(2),
- VK_QUERY_RESULT_PARTIAL_BIT = VK_BIT(3),
+ VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+ VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
};
-typedef deUint32 VkQueryResultFlags;
+typedef deUint32 VkCmdPoolCreateFlags;
-enum VkPhysicalDeviceCompatibilityFlagBits
+enum VkCmdPoolResetFlagBits
{
- VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT = VK_BIT(0),
- VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT = VK_BIT(1),
- VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT = VK_BIT(2),
- VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT = VK_BIT(3),
- VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT = VK_BIT(4),
- VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT = VK_BIT(5),
- VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT = VK_BIT(6),
+ VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001,
};
-typedef deUint32 VkPhysicalDeviceCompatibilityFlags;
+typedef deUint32 VkCmdPoolResetFlags;
enum VkCmdBufferOptimizeFlagBits
{
- VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = VK_BIT(0),
- VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = VK_BIT(1),
- VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = VK_BIT(2),
- VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = VK_BIT(3),
+ 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,
};
typedef deUint32 VkCmdBufferOptimizeFlags;
-enum VkQueryPipelineStatisticFlagBits
+enum VkCmdBufferResetFlagBits
{
- VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = VK_BIT(0),
- VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = VK_BIT(1),
- VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = VK_BIT(2),
- VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = VK_BIT(3),
- VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = VK_BIT(4),
- VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = VK_BIT(5),
- VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = VK_BIT(6),
- VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = VK_BIT(7),
- VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = VK_BIT(8),
- VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = VK_BIT(9),
- VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = VK_BIT(10),
+ VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001,
};
-typedef deUint32 VkQueryPipelineStatisticFlags;
+typedef deUint32 VkCmdBufferResetFlags;
+
+enum VkImageAspectFlagBits
+{
+ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+ VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+};
+typedef deUint32 VkImageAspectFlags;
+
+enum VkQueryControlFlagBits
+{
+ VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
+};
+typedef deUint32 VkQueryControlFlags;
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkObject);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkInstance);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkPhysicalDevice);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDevice);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkQueue);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkCmdBuffer);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkNonDispatchable);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDeviceMemory);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkBuffer);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkBufferView);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkImage);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkImageView);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkColorAttachmentView);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDepthStencilView);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkShader);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkPipeline);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkPipelineLayout);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkSampler);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDescriptorSet);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDescriptorSetLayout);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDescriptorPool);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicStateObject);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicVpState);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicRsState);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicCbState);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkDynamicDsState);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkFence);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkSemaphore);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkEvent);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkQueryPool);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkFramebuffer);
-VK_DEFINE_HANDLE_TYPE_TRAITS(VkRenderPass);
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult getPhysicalDeviceInfo (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData) const;
-virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const;
-virtual VkResult destroyDevice (VkDevice device) const;
-virtual VkResult getGlobalExtensionInfo (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const;
-virtual VkResult getPhysicalDeviceExtensionInfo (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const;
-virtual VkResult enumerateLayers (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved) const;
-virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue) const;
-virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const;
-virtual VkResult queueAddMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const;
-virtual VkResult queueRemoveMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const;
-virtual VkResult queueWaitIdle (VkQueue queue) const;
-virtual VkResult deviceWaitIdle (VkDevice device) const;
-virtual VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const;
-virtual VkResult freeMemory (VkDevice device, VkDeviceMemory mem) const;
-virtual VkResult setMemoryPriority (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) const;
-virtual VkResult mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const;
-virtual VkResult unmapMemory (VkDevice device, VkDeviceMemory mem) const;
-virtual VkResult flushMappedMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) const;
-virtual VkResult pinSystemMemory (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem) const;
-virtual VkResult getMultiDeviceCompatibility (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo) const;
-virtual VkResult openSharedMemory (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const;
-virtual VkResult openSharedSemaphore (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) const;
-virtual VkResult openPeerMemory (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const;
-virtual VkResult openPeerImage (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) const;
-virtual VkResult destroyObject (VkDevice device, VkObjectType objType, VkObject object) const;
-virtual VkResult getObjectInfo (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData) const;
-virtual VkResult queueBindObjectMemory (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset) const;
-virtual VkResult queueBindObjectMemoryRange (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) const;
-virtual VkResult queueBindImageMemoryRange (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) const;
-virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const;
-virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, VkFence* pFences) const;
-virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const;
-virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout) const;
-virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const;
-virtual VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const;
-virtual VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const;
-virtual VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const;
-virtual VkResult getEventStatus (VkDevice device, VkEvent event) const;
-virtual VkResult setEvent (VkDevice device, VkEvent event) const;
-virtual VkResult resetEvent (VkDevice device, VkEvent event) const;
-virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const;
-virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const;
-virtual VkResult getFormatInfo (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData) const;
-virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const;
-virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const;
-virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const;
-virtual VkResult getImageSubresourceInfo (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData) const;
-virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const;
-virtual VkResult createColorAttachmentView (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) const;
-virtual VkResult createDepthStencilView (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) const;
-virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const;
-virtual VkResult createGraphicsPipeline (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const;
-virtual VkResult createGraphicsPipelineDerivative (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) const;
-virtual VkResult createComputePipeline (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const;
-virtual VkResult storePipeline (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData) const;
-virtual VkResult loadPipeline (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline) const;
-virtual VkResult loadPipelineDerivative (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) const;
-virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const;
-virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const;
-virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const;
-virtual VkResult beginDescriptorPoolUpdate (VkDevice device, VkDescriptorUpdateMode updateMode) const;
-virtual VkResult endDescriptorPoolUpdate (VkDevice device, VkCmdBuffer cmd) const;
-virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const;
-virtual VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const;
-virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const;
-virtual void clearDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const;
-virtual void updateDescriptors (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray) const;
-virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) const;
-virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) const;
-virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) const;
-virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) const;
-virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const;
-virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const;
-virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const;
-virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer) const;
-virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const;
-virtual void cmdBindDynamicStateObject (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState) const;
-virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const;
-virtual void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const;
-virtual void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const;
-virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const;
-virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const;
-virtual void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const;
-virtual void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const;
-virtual void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const;
-virtual void cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const;
-virtual void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const;
-virtual void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const;
-virtual void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions) const;
-virtual void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const;
-virtual void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const;
-virtual void cmdCloneImageData (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) const;
-virtual void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const;
-virtual void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const;
-virtual void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
-virtual void cmdClearDepthStencil (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
-virtual void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const;
-virtual void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const;
-virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const;
-virtual void cmdWaitEvents (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const;
-virtual void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const;
-virtual void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const;
-virtual void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const;
-virtual void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const;
-virtual void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const;
-virtual void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const;
-virtual void cmdInitAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData) const;
-virtual void cmdLoadAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) const;
-virtual void cmdSaveAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) const;
-virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const;
-virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const;
-virtual void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) const;
-virtual void cmdEndRenderPass (VkCmdBuffer cmdBuffer, VkRenderPass renderPass) const;
+virtual VkResult destroyDevice (VkDevice device) const;
+virtual VkResult getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const;
+virtual VkResult getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const;
+virtual VkResult getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const;
+virtual VkResult getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const;
+virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const;
+virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const;
+virtual VkResult queueWaitIdle (VkQueue queue) const;
+virtual VkResult deviceWaitIdle (VkDevice device) const;
+virtual VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const;
+virtual VkResult freeMemory (VkDevice device, VkDeviceMemory mem) const;
+virtual VkResult mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const;
+virtual VkResult unmapMemory (VkDevice device, VkDeviceMemory mem) const;
+virtual VkResult flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const;
+virtual VkResult invalidateMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const;
+virtual VkResult getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const;
+virtual VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) const;
+virtual VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) const;
+virtual VkResult getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const;
+virtual VkResult getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const;
+virtual VkResult getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const;
+virtual VkResult getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, deUint32 samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pNumProperties, VkSparseImageFormatProperties* pProperties) const;
+virtual VkResult queueBindSparseBufferMemory (VkQueue queue, VkBuffer buffer, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const;
+virtual VkResult queueBindSparseImageOpaqueMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const;
+virtual VkResult queueBindSparseImageMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) const;
+virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const;
+virtual VkResult destroyFence (VkDevice device, VkFence fence) const;
+virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const;
+virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const;
+virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout) const;
+virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const;
+virtual VkResult destroySemaphore (VkDevice device, VkSemaphore semaphore) const;
+virtual VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const;
+virtual VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const;
+virtual VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const;
+virtual VkResult destroyEvent (VkDevice device, VkEvent event) const;
+virtual VkResult getEventStatus (VkDevice device, VkEvent event) const;
+virtual VkResult setEvent (VkDevice device, VkEvent event) const;
+virtual VkResult resetEvent (VkDevice device, VkEvent event) const;
+virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const;
+virtual VkResult destroyQueryPool (VkDevice device, VkQueryPool queryPool) const;
+virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const;
+virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const;
+virtual VkResult destroyBuffer (VkDevice device, VkBuffer buffer) const;
+virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const;
+virtual VkResult destroyBufferView (VkDevice device, VkBufferView bufferView) const;
+virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const;
+virtual VkResult destroyImage (VkDevice device, VkImage image) const;
+virtual VkResult getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const;
+virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const;
+virtual VkResult destroyImageView (VkDevice device, VkImageView imageView) const;
+virtual VkResult createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) const;
+virtual VkResult destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView) const;
+virtual VkResult createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) const;
+virtual VkResult destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const;
+virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const;
+virtual VkResult destroyShader (VkDevice device, VkShader shader) const;
+virtual VkResult createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) const;
+virtual VkResult destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const;
+virtual deUintptr getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache) const;
+virtual VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, void* pData) const;
+virtual VkResult mergePipelineCaches (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches) const;
+virtual VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const;
+virtual VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const;
+virtual VkResult destroyPipeline (VkDevice device, VkPipeline pipeline) const;
+virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const;
+virtual VkResult destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const;
+virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const;
+virtual VkResult destroySampler (VkDevice device, VkSampler sampler) const;
+virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const;
+virtual VkResult destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const;
+virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const;
+virtual VkResult destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const;
+virtual VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const;
+virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const;
+virtual VkResult updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const;
+virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) const;
+virtual VkResult destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState) const;
+virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) const;
+virtual VkResult destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState) const;
+virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) const;
+virtual VkResult destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) const;
+virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) const;
+virtual VkResult destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) const;
+virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const;
+virtual VkResult destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const;
+virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const;
+virtual VkResult destroyRenderPass (VkDevice device, VkRenderPass renderPass) const;
+virtual VkResult getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const;
+virtual VkResult createCommandPool (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) const;
+virtual VkResult destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const;
+virtual VkResult resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) const;
+virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const;
+virtual VkResult destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const;
+virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const;
+virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const;
+virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) const;
+virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const;
+virtual void cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) const;
+virtual void cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) const;
+virtual void cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) const;
+virtual void cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) const;
+virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const;
+virtual void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const;
+virtual void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const;
+virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const;
+virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const;
+virtual void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const;
+virtual void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const;
+virtual void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const;
+virtual void cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const;
+virtual void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const;
+virtual void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const;
+virtual void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkTexFilter filter) const;
+virtual void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const;
+virtual void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const;
+virtual void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const;
+virtual void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const;
+virtual void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
+virtual void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const;
+virtual void cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects) const;
+virtual void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects) const;
+virtual void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const;
+virtual void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const;
+virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const;
+virtual void cmdWaitEvents (VkCmdBuffer cmdBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, deUint32 memBarrierCount, const void* const* ppMemBarriers) const;
+virtual void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, deUint32 memBarrierCount, const void* const* ppMemBarriers) const;
+virtual void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const;
+virtual void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const;
+virtual void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const;
+virtual void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const;
+virtual void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const;
+virtual void cmdPushConstants (VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 start, deUint32 length, const void* values) const;
+virtual void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) const;
+virtual void cmdNextSubpass (VkCmdBuffer cmdBuffer, VkRenderPassContents contents) const;
+virtual void cmdEndRenderPass (VkCmdBuffer cmdBuffer) const;
+virtual void cmdExecuteCommands (VkCmdBuffer cmdBuffer, deUint32 cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) const;
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+virtual VkResult destroyInstance (VkInstance instance) const;
+virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const;
+virtual VkResult getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const;
+virtual VkResult getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const;
+virtual VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) const;
+virtual VkResult getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) const;
+virtual VkResult getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const;
+virtual VkResult getPhysicalDeviceQueueCount (VkPhysicalDevice physicalDevice, deUint32* pCount) const;
+virtual VkResult getPhysicalDeviceQueueProperties (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties) const;
+virtual VkResult getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const;
+virtual PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, const char* pName) const;
+virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const;
-virtual VkResult destroyInstance (VkInstance instance) const;
-virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const;
-virtual FunctionPtr getProcAddr (VkPhysicalDevice physicalDevice, const char* pName) const;
+virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const;
+virtual PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, const char* pName) const;
DE_STATIC_ASSERT(sizeof(vk::VkImageType) == sizeof(deUint32));
DE_STATIC_ASSERT(sizeof(vk::VkResult) == sizeof(deUint32));
+DE_STATIC_ASSERT(sizeof(vk::VkDevice) == sizeof(deUint64));
namespace vk
{
return (version.major << 22) | (version.minor << 12) | version.patch;
}
-#include "vkGetObjectTypeImpl.inl"
+VkClearValue clearValueColorF32 (float r, float g, float b, float a)
+{
+ VkClearValue v;
+ v.color.f32[0] = r;
+ v.color.f32[1] = g;
+ v.color.f32[2] = b;
+ v.color.f32[3] = a;
+ return v;
+}
} // vk
# define VK_APIENTRY
#endif
-#define VK_DEFINE_HANDLE_TYPE_TRAITS(HANDLE) \
- struct HANDLE##T { private: HANDLE##T (void); }; \
- template<> \
- struct Traits<HANDLE##T> \
- { \
- typedef HANDLE Type; \
- }
-
-#if (DE_PTR_SIZE == 8)
-# define VK_DEFINE_PTR_HANDLE(HANDLE) \
- struct HANDLE##_s { private: HANDLE##_s (void); }; \
- typedef HANDLE##_s* HANDLE
-
-# define VK_DEFINE_PTR_SUBCLASS_HANDLE(HANDLE, PARENT) \
- struct HANDLE##_s : public PARENT##_s { private: HANDLE##_s (void); }; \
- typedef HANDLE##_s* HANDLE
-
-# define VK_DEFINE_BASE_HANDLE(HANDLE) VK_DEFINE_PTR_HANDLE(HANDLE)
-# define VK_DEFINE_DISP_SUBCLASS_HANDLE(HANDLE, PARENT) VK_DEFINE_PTR_SUBCLASS_HANDLE(HANDLE, PARENT)
-# define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(HANDLE, PARENT) VK_DEFINE_PTR_SUBCLASS_HANDLE(HANDLE, PARENT)
-#else
-# define VK_DEFINE_BASE_HANDLE(HANDLE) typedef deUint64 HANDLE
-# define VK_DEFINE_DISP_SUBCLASS_HANDLE(HANDLE, PARENT) typedef deUintptr HANDLE
-# define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(HANDLE, PARENT) typedef deUint64 HANDLE
-#endif
+#define VK_DEFINE_HANDLE(NAME, TYPE) typedef Handle<TYPE> NAME
+#define VK_DEFINE_NONDISP_HANDLE(NAME, TYPE) VK_DEFINE_HANDLE(NAME, TYPE)
#define VK_MAKE_VERSION(MAJOR, MINOR, PATCH) ((MAJOR << 22) | (MINOR << 12) | PATCH)
#define VK_BIT(NUM) (1<<NUM)
typedef deUint64 VkDeviceSize;
typedef deUint32 VkSampleMask;
+typedef deUint32 VkBool32;
typedef deUint32 VkShaderCreateFlags; // Reserved
typedef deUint32 VkEventCreateFlags; // Reserved
typedef deUint32 VkCmdBufferCreateFlags; // Reserved
+typedef deUint32 VkSemaphoreCreateFlags; // Reserved
+typedef deUint32 VkShaderModuleCreateFlags; // Reserved
typedef deUint32 VkMemoryMapFlags; // \todo [2015-05-08 pyry] Reserved? Not documented
-template<typename T> struct Traits;
+// enum HandleType { HANDLE_TYPE_INSTANCE, ... };
+#include "vkHandleType.inl"
-#include "vkBasicTypes.inl"
+template<HandleType Type>
+class Handle
+{
+public:
+ Handle (void) {} // \note Left uninitialized on purpose
+ Handle (deUint64 internal) : m_internal(internal) {}
-typedef VK_APICALL void (VK_APIENTRY* FunctionPtr) (void);
+ Handle& operator= (deUint64 internal) { m_internal = internal; return *this; }
-typedef VK_APICALL void* (VK_APIENTRY* PFN_vkAllocFunction) (void* pUserData, deUintptr size, deUintptr alignment, VkSystemAllocType allocType);
-typedef VK_APICALL void (VK_APIENTRY* PFN_vkFreeFunction) (void* pUserData, void* pMem);
+ bool operator== (const Handle<Type>& other) const { return this->m_internal == other.m_internal; }
+ bool operator!= (const Handle<Type>& other) const { return this->m_internal != other.m_internal; }
-union VkClearColorValue
-{
- float floatColor[4];
- deUint32 rawColor[4];
+ bool operator! (void) const { return !m_internal; }
- VkClearColorValue (float r, float g, float b, float a)
- {
- floatColor[0] = r;
- floatColor[1] = g;
- floatColor[2] = b;
- floatColor[3] = a;
- }
+ deUint64 getInternal (void) const { return m_internal; }
- VkClearColorValue (deUint32 r, deUint32 g, deUint32 b, deUint32 a)
- {
- rawColor[0] = r;
- rawColor[1] = g;
- rawColor[2] = b;
- rawColor[3] = a;
- }
+ enum { HANDLE_TYPE = Type };
+
+private:
+ deUint64 m_internal;
};
+#include "vkBasicTypes.inl"
+
+typedef VK_APICALL void (VK_APIENTRY* PFN_vkVoidFunction) (void);
+
+typedef VK_APICALL void* (VK_APIENTRY* PFN_vkAllocFunction) (void* pUserData, deUintptr size, deUintptr alignment, VkSystemAllocType allocType);
+typedef VK_APICALL void (VK_APIENTRY* PFN_vkFreeFunction) (void* pUserData, void* pMem);
+
#include "vkStructTypes.inl"
+extern "C"
+{
+#include "vkFunctionPointerTypes.inl"
+}
+
class PlatformInterface
{
public:
#include "vkVirtualPlatformInterface.inl"
+
+protected:
+ PlatformInterface (void) {}
+
+private:
+ PlatformInterface (const PlatformInterface&);
+ PlatformInterface& operator= (const PlatformInterface&);
+};
+
+class InstanceInterface
+{
+public:
+#include "vkVirtualInstanceInterface.inl"
+
+protected:
+ InstanceInterface (void) {}
+
+private:
+ InstanceInterface (const InstanceInterface&);
+ InstanceInterface& operator= (const InstanceInterface&);
};
class DeviceInterface
{
public:
#include "vkVirtualDeviceInterface.inl"
+
+protected:
+ DeviceInterface (void) {}
+
+private:
+ DeviceInterface (const DeviceInterface&);
+ DeviceInterface& operator= (const DeviceInterface&);
};
struct ApiVersion
const VkResult m_error;
};
-ApiVersion unpackVersion (deUint32 version);
-deUint32 pack (const ApiVersion& version);
+void checkResult (VkResult result, const char* message, const char* file, int line);
-void checkResult (VkResult result, const char* message, const char* file, int line);
+ApiVersion unpackVersion (deUint32 version);
+deUint32 pack (const ApiVersion& version);
-//! Map Vk{Object}T to VK_OBJECT_TYPE_{OBJECT}. Defined for leaf objects only.
-template<typename T>
-VkObjectType getObjectType (void);
+VkClearValue clearValueColorF32 (float r, float g, float b, float a);
} // vk
* be lost! Modify the generating script instead.
*/
-VkResult DeviceDriver::getPhysicalDeviceInfo (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData) const
-{
- return m_vk.getPhysicalDeviceInfo(physicalDevice, infoType, pDataSize, pData);
-}
-
-VkResult DeviceDriver::createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const
-{
- return m_vk.createDevice(physicalDevice, pCreateInfo, pDevice);
-}
-
VkResult DeviceDriver::destroyDevice (VkDevice device) const
{
return m_vk.destroyDevice(device);
}
-VkResult DeviceDriver::getGlobalExtensionInfo (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const
+VkResult DeviceDriver::getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const
{
- return m_vk.getGlobalExtensionInfo(infoType, extensionIndex, pDataSize, pData);
+ return m_vk.getGlobalExtensionProperties(pLayerName, pCount, pProperties);
}
-VkResult DeviceDriver::getPhysicalDeviceExtensionInfo (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const
+VkResult DeviceDriver::getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const
{
- return m_vk.getPhysicalDeviceExtensionInfo(physicalDevice, infoType, extensionIndex, pDataSize, pData);
+ return m_vk.getPhysicalDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
}
-VkResult DeviceDriver::enumerateLayers (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved) const
+VkResult DeviceDriver::getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const
{
- return m_vk.enumerateLayers(physicalDevice, maxStringSize, pLayerCount, pOutLayers, pReserved);
+ return m_vk.getGlobalLayerProperties(pCount, pProperties);
}
-VkResult DeviceDriver::getDeviceQueue (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue) const
+VkResult DeviceDriver::getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const
{
- return m_vk.getDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ return m_vk.getPhysicalDeviceLayerProperties(physicalDevice, pCount, pProperties);
}
-VkResult DeviceDriver::queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const
+VkResult DeviceDriver::getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const
{
- return m_vk.queueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+ return m_vk.getDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
-VkResult DeviceDriver::queueAddMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const
-{
- return m_vk.queueAddMemReferences(queue, count, pMems);
-}
-
-VkResult DeviceDriver::queueRemoveMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const
+VkResult DeviceDriver::queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const
{
- return m_vk.queueRemoveMemReferences(queue, count, pMems);
+ return m_vk.queueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
}
VkResult DeviceDriver::queueWaitIdle (VkQueue queue) const
return m_vk.freeMemory(device, mem);
}
-VkResult DeviceDriver::setMemoryPriority (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) const
-{
- return m_vk.setMemoryPriority(device, mem, priority);
-}
-
VkResult DeviceDriver::mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const
{
return m_vk.mapMemory(device, mem, offset, size, flags, ppData);
return m_vk.unmapMemory(device, mem);
}
-VkResult DeviceDriver::flushMappedMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) const
+VkResult DeviceDriver::flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const
{
- return m_vk.flushMappedMemory(device, mem, offset, size);
+ return m_vk.flushMappedMemoryRanges(device, memRangeCount, pMemRanges);
}
-VkResult DeviceDriver::pinSystemMemory (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem) const
+VkResult DeviceDriver::invalidateMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const
{
- return m_vk.pinSystemMemory(device, pSysMem, memSize, pMem);
+ return m_vk.invalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
}
-VkResult DeviceDriver::getMultiDeviceCompatibility (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo) const
+VkResult DeviceDriver::getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const
{
- return m_vk.getMultiDeviceCompatibility(physicalDevice0, physicalDevice1, pInfo);
+ return m_vk.getDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
}
-VkResult DeviceDriver::openSharedMemory (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const
+VkResult DeviceDriver::bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) const
{
- return m_vk.openSharedMemory(device, pOpenInfo, pMem);
+ return m_vk.bindBufferMemory(device, buffer, mem, memOffset);
}
-VkResult DeviceDriver::openSharedSemaphore (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) const
+VkResult DeviceDriver::bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) const
{
- return m_vk.openSharedSemaphore(device, pOpenInfo, pSemaphore);
+ return m_vk.bindImageMemory(device, image, mem, memOffset);
}
-VkResult DeviceDriver::openPeerMemory (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const
+VkResult DeviceDriver::getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const
{
- return m_vk.openPeerMemory(device, pOpenInfo, pMem);
+ return m_vk.getBufferMemoryRequirements(device, buffer, pMemoryRequirements);
}
-VkResult DeviceDriver::openPeerImage (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) const
+VkResult DeviceDriver::getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const
{
- return m_vk.openPeerImage(device, pOpenInfo, pImage, pMem);
+ return m_vk.getImageMemoryRequirements(device, image, pMemoryRequirements);
}
-VkResult DeviceDriver::destroyObject (VkDevice device, VkObjectType objType, VkObject object) const
+VkResult DeviceDriver::getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const
{
- return m_vk.destroyObject(device, objType, object);
+ return m_vk.getImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
}
-VkResult DeviceDriver::getObjectInfo (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData) const
+VkResult DeviceDriver::getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, deUint32 samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pNumProperties, VkSparseImageFormatProperties* pProperties) const
{
- return m_vk.getObjectInfo(device, objType, object, infoType, pDataSize, pData);
+ return m_vk.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
}
-VkResult DeviceDriver::queueBindObjectMemory (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset) const
+VkResult DeviceDriver::queueBindSparseBufferMemory (VkQueue queue, VkBuffer buffer, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const
{
- return m_vk.queueBindObjectMemory(queue, objType, object, allocationIdx, mem, memOffset);
+ return m_vk.queueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
}
-VkResult DeviceDriver::queueBindObjectMemoryRange (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) const
+VkResult DeviceDriver::queueBindSparseImageOpaqueMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const
{
- return m_vk.queueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ return m_vk.queueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
}
-VkResult DeviceDriver::queueBindImageMemoryRange (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) const
+VkResult DeviceDriver::queueBindSparseImageMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) const
{
- return m_vk.queueBindImageMemoryRange(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+ return m_vk.queueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
}
VkResult DeviceDriver::createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const
return m_vk.createFence(device, pCreateInfo, pFence);
}
-VkResult DeviceDriver::resetFences (VkDevice device, deUint32 fenceCount, VkFence* pFences) const
+VkResult DeviceDriver::destroyFence (VkDevice device, VkFence fence) const
+{
+ return m_vk.destroyFence(device, fence);
+}
+
+VkResult DeviceDriver::resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const
{
return m_vk.resetFences(device, fenceCount, pFences);
}
return m_vk.getFenceStatus(device, fence);
}
-VkResult DeviceDriver::waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout) const
+VkResult DeviceDriver::waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout) const
{
return m_vk.waitForFences(device, fenceCount, pFences, waitAll, timeout);
}
return m_vk.createSemaphore(device, pCreateInfo, pSemaphore);
}
+VkResult DeviceDriver::destroySemaphore (VkDevice device, VkSemaphore semaphore) const
+{
+ return m_vk.destroySemaphore(device, semaphore);
+}
+
VkResult DeviceDriver::queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const
{
return m_vk.queueSignalSemaphore(queue, semaphore);
return m_vk.createEvent(device, pCreateInfo, pEvent);
}
+VkResult DeviceDriver::destroyEvent (VkDevice device, VkEvent event) const
+{
+ return m_vk.destroyEvent(device, event);
+}
+
VkResult DeviceDriver::getEventStatus (VkDevice device, VkEvent event) const
{
return m_vk.getEventStatus(device, event);
return m_vk.createQueryPool(device, pCreateInfo, pQueryPool);
}
-VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const
+VkResult DeviceDriver::destroyQueryPool (VkDevice device, VkQueryPool queryPool) const
{
- return m_vk.getQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
+ return m_vk.destroyQueryPool(device, queryPool);
}
-VkResult DeviceDriver::getFormatInfo (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData) const
+VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const
{
- return m_vk.getFormatInfo(device, format, infoType, pDataSize, pData);
+ return m_vk.getQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
}
VkResult DeviceDriver::createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const
return m_vk.createBuffer(device, pCreateInfo, pBuffer);
}
+VkResult DeviceDriver::destroyBuffer (VkDevice device, VkBuffer buffer) const
+{
+ return m_vk.destroyBuffer(device, buffer);
+}
+
VkResult DeviceDriver::createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const
{
return m_vk.createBufferView(device, pCreateInfo, pView);
}
+VkResult DeviceDriver::destroyBufferView (VkDevice device, VkBufferView bufferView) const
+{
+ return m_vk.destroyBufferView(device, bufferView);
+}
+
VkResult DeviceDriver::createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const
{
return m_vk.createImage(device, pCreateInfo, pImage);
}
-VkResult DeviceDriver::getImageSubresourceInfo (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData) const
+VkResult DeviceDriver::destroyImage (VkDevice device, VkImage image) const
{
- return m_vk.getImageSubresourceInfo(device, image, pSubresource, infoType, pDataSize, pData);
+ return m_vk.destroyImage(device, image);
+}
+
+VkResult DeviceDriver::getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const
+{
+ return m_vk.getImageSubresourceLayout(device, image, pSubresource, pLayout);
}
VkResult DeviceDriver::createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const
return m_vk.createImageView(device, pCreateInfo, pView);
}
-VkResult DeviceDriver::createColorAttachmentView (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) const
+VkResult DeviceDriver::destroyImageView (VkDevice device, VkImageView imageView) const
{
- return m_vk.createColorAttachmentView(device, pCreateInfo, pView);
+ return m_vk.destroyImageView(device, imageView);
}
-VkResult DeviceDriver::createDepthStencilView (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) const
+VkResult DeviceDriver::createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) const
{
- return m_vk.createDepthStencilView(device, pCreateInfo, pView);
+ return m_vk.createAttachmentView(device, pCreateInfo, pView);
+}
+
+VkResult DeviceDriver::destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView) const
+{
+ return m_vk.destroyAttachmentView(device, attachmentView);
+}
+
+VkResult DeviceDriver::createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) const
+{
+ return m_vk.createShaderModule(device, pCreateInfo, pShaderModule);
+}
+
+VkResult DeviceDriver::destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const
+{
+ return m_vk.destroyShaderModule(device, shaderModule);
}
VkResult DeviceDriver::createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const
return m_vk.createShader(device, pCreateInfo, pShader);
}
-VkResult DeviceDriver::createGraphicsPipeline (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const
+VkResult DeviceDriver::destroyShader (VkDevice device, VkShader shader) const
+{
+ return m_vk.destroyShader(device, shader);
+}
+
+VkResult DeviceDriver::createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) const
+{
+ return m_vk.createPipelineCache(device, pCreateInfo, pPipelineCache);
+}
+
+VkResult DeviceDriver::destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const
+{
+ return m_vk.destroyPipelineCache(device, pipelineCache);
+}
+
+deUintptr DeviceDriver::getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache) const
{
- return m_vk.createGraphicsPipeline(device, pCreateInfo, pPipeline);
+ return m_vk.getPipelineCacheSize(device, pipelineCache);
}
-VkResult DeviceDriver::createGraphicsPipelineDerivative (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) const
+VkResult DeviceDriver::getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, void* pData) const
{
- return m_vk.createGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+ return m_vk.getPipelineCacheData(device, pipelineCache, pData);
}
-VkResult DeviceDriver::createComputePipeline (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const
+VkResult DeviceDriver::mergePipelineCaches (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches) const
{
- return m_vk.createComputePipeline(device, pCreateInfo, pPipeline);
+ return m_vk.mergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
}
-VkResult DeviceDriver::storePipeline (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData) const
+VkResult DeviceDriver::createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const
{
- return m_vk.storePipeline(device, pipeline, pDataSize, pData);
+ return m_vk.createGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
}
-VkResult DeviceDriver::loadPipeline (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline) const
+VkResult DeviceDriver::createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const
{
- return m_vk.loadPipeline(device, dataSize, pData, pPipeline);
+ return m_vk.createComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
}
-VkResult DeviceDriver::loadPipelineDerivative (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) const
+VkResult DeviceDriver::destroyPipeline (VkDevice device, VkPipeline pipeline) const
{
- return m_vk.loadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
+ return m_vk.destroyPipeline(device, pipeline);
}
VkResult DeviceDriver::createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const
return m_vk.createPipelineLayout(device, pCreateInfo, pPipelineLayout);
}
+VkResult DeviceDriver::destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const
+{
+ return m_vk.destroyPipelineLayout(device, pipelineLayout);
+}
+
VkResult DeviceDriver::createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const
{
return m_vk.createSampler(device, pCreateInfo, pSampler);
}
-VkResult DeviceDriver::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const
+VkResult DeviceDriver::destroySampler (VkDevice device, VkSampler sampler) const
{
- return m_vk.createDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+ return m_vk.destroySampler(device, sampler);
}
-VkResult DeviceDriver::beginDescriptorPoolUpdate (VkDevice device, VkDescriptorUpdateMode updateMode) const
+VkResult DeviceDriver::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const
{
- return m_vk.beginDescriptorPoolUpdate(device, updateMode);
+ return m_vk.createDescriptorSetLayout(device, pCreateInfo, pSetLayout);
}
-VkResult DeviceDriver::endDescriptorPoolUpdate (VkDevice device, VkCmdBuffer cmd) const
+VkResult DeviceDriver::destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const
{
- return m_vk.endDescriptorPoolUpdate(device, cmd);
+ return m_vk.destroyDescriptorSetLayout(device, descriptorSetLayout);
}
VkResult DeviceDriver::createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const
return m_vk.createDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
}
+VkResult DeviceDriver::destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const
+{
+ return m_vk.destroyDescriptorPool(device, descriptorPool);
+}
+
VkResult DeviceDriver::resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const
{
return m_vk.resetDescriptorPool(device, descriptorPool);
return m_vk.allocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
}
-void DeviceDriver::clearDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const
+VkResult DeviceDriver::updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const
{
- m_vk.clearDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+ return m_vk.updateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
}
-void DeviceDriver::updateDescriptors (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray) const
+VkResult DeviceDriver::createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) const
{
- m_vk.updateDescriptors(device, descriptorSet, updateCount, ppUpdateArray);
+ return m_vk.createDynamicViewportState(device, pCreateInfo, pState);
}
-VkResult DeviceDriver::createDynamicViewportState (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) const
+VkResult DeviceDriver::destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState) const
{
- return m_vk.createDynamicViewportState(device, pCreateInfo, pState);
+ return m_vk.destroyDynamicViewportState(device, dynamicViewportState);
}
-VkResult DeviceDriver::createDynamicRasterState (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) const
+VkResult DeviceDriver::createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) const
{
return m_vk.createDynamicRasterState(device, pCreateInfo, pState);
}
-VkResult DeviceDriver::createDynamicColorBlendState (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) const
+VkResult DeviceDriver::destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState) const
+{
+ return m_vk.destroyDynamicRasterState(device, dynamicRasterState);
+}
+
+VkResult DeviceDriver::createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) const
{
return m_vk.createDynamicColorBlendState(device, pCreateInfo, pState);
}
-VkResult DeviceDriver::createDynamicDepthStencilState (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) const
+VkResult DeviceDriver::destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) const
+{
+ return m_vk.destroyDynamicColorBlendState(device, dynamicColorBlendState);
+}
+
+VkResult DeviceDriver::createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) const
{
return m_vk.createDynamicDepthStencilState(device, pCreateInfo, pState);
}
+VkResult DeviceDriver::destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) const
+{
+ return m_vk.destroyDynamicDepthStencilState(device, dynamicDepthStencilState);
+}
+
+VkResult DeviceDriver::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const
+{
+ return m_vk.createFramebuffer(device, pCreateInfo, pFramebuffer);
+}
+
+VkResult DeviceDriver::destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const
+{
+ return m_vk.destroyFramebuffer(device, framebuffer);
+}
+
+VkResult DeviceDriver::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const
+{
+ return m_vk.createRenderPass(device, pCreateInfo, pRenderPass);
+}
+
+VkResult DeviceDriver::destroyRenderPass (VkDevice device, VkRenderPass renderPass) const
+{
+ return m_vk.destroyRenderPass(device, renderPass);
+}
+
+VkResult DeviceDriver::getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const
+{
+ return m_vk.getRenderAreaGranularity(device, renderPass, pGranularity);
+}
+
+VkResult DeviceDriver::createCommandPool (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) const
+{
+ return m_vk.createCommandPool(device, pCreateInfo, pCmdPool);
+}
+
+VkResult DeviceDriver::destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const
+{
+ return m_vk.destroyCommandPool(device, cmdPool);
+}
+
+VkResult DeviceDriver::resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) const
+{
+ return m_vk.resetCommandPool(device, cmdPool, flags);
+}
+
VkResult DeviceDriver::createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const
{
return m_vk.createCommandBuffer(device, pCreateInfo, pCmdBuffer);
}
+VkResult DeviceDriver::destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const
+{
+ return m_vk.destroyCommandBuffer(device, commandBuffer);
+}
+
VkResult DeviceDriver::beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const
{
return m_vk.beginCommandBuffer(cmdBuffer, pBeginInfo);
return m_vk.endCommandBuffer(cmdBuffer);
}
-VkResult DeviceDriver::resetCommandBuffer (VkCmdBuffer cmdBuffer) const
+VkResult DeviceDriver::resetCommandBuffer (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) const
{
- return m_vk.resetCommandBuffer(cmdBuffer);
+ return m_vk.resetCommandBuffer(cmdBuffer, flags);
}
void DeviceDriver::cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
m_vk.cmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
-void DeviceDriver::cmdBindDynamicStateObject (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState) const
+void DeviceDriver::cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) const
+{
+ m_vk.cmdBindDynamicViewportState(cmdBuffer, dynamicViewportState);
+}
+
+void DeviceDriver::cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) const
{
- m_vk.cmdBindDynamicStateObject(cmdBuffer, stateBindPoint, dynamicState);
+ m_vk.cmdBindDynamicRasterState(cmdBuffer, dynamicRasterState);
}
-void DeviceDriver::cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const
+void DeviceDriver::cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) const
{
- m_vk.cmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ m_vk.cmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState);
+}
+
+void DeviceDriver::cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) const
+{
+ m_vk.cmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState);
+}
+
+void DeviceDriver::cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const
+{
+ m_vk.cmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
void DeviceDriver::cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
m_vk.cmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-void DeviceDriver::cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions) const
+void DeviceDriver::cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkTexFilter filter) const
{
- m_vk.cmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+ m_vk.cmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
}
void DeviceDriver::cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const
m_vk.cmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
-void DeviceDriver::cmdCloneImageData (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) const
-{
- m_vk.cmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
-}
-
void DeviceDriver::cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const
{
m_vk.cmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
m_vk.cmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
-void DeviceDriver::cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
+void DeviceDriver::cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
{
- m_vk.cmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
+ m_vk.cmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
-void DeviceDriver::cmdClearDepthStencil (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
+void DeviceDriver::cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
{
- m_vk.cmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+ m_vk.cmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+}
+
+void DeviceDriver::cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects) const
+{
+ m_vk.cmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
+}
+
+void DeviceDriver::cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects) const
+{
+ m_vk.cmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects);
}
void DeviceDriver::cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const
m_vk.cmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
-void DeviceDriver::cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const
+void DeviceDriver::cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
{
- m_vk.cmdSetEvent(cmdBuffer, event, pipeEvent);
+ m_vk.cmdSetEvent(cmdBuffer, event, stageMask);
}
-void DeviceDriver::cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const
+void DeviceDriver::cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
{
- m_vk.cmdResetEvent(cmdBuffer, event, pipeEvent);
+ m_vk.cmdResetEvent(cmdBuffer, event, stageMask);
}
-void DeviceDriver::cmdWaitEvents (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const
+void DeviceDriver::cmdWaitEvents (VkCmdBuffer cmdBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, deUint32 memBarrierCount, const void* const* ppMemBarriers) const
{
- m_vk.cmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+ m_vk.cmdWaitEvents(cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers);
}
-void DeviceDriver::cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const
+void DeviceDriver::cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, deUint32 memBarrierCount, const void* const* ppMemBarriers) const
{
- m_vk.cmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+ m_vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
}
void DeviceDriver::cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const
m_vk.cmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
}
-void DeviceDriver::cmdInitAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData) const
+void DeviceDriver::cmdPushConstants (VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 start, deUint32 length, const void* values) const
{
- m_vk.cmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
+ m_vk.cmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
}
-void DeviceDriver::cmdLoadAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) const
+void DeviceDriver::cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) const
{
- m_vk.cmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
+ m_vk.cmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
}
-void DeviceDriver::cmdSaveAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) const
+void DeviceDriver::cmdNextSubpass (VkCmdBuffer cmdBuffer, VkRenderPassContents contents) const
{
- m_vk.cmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
-}
-
-VkResult DeviceDriver::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const
-{
- return m_vk.createFramebuffer(device, pCreateInfo, pFramebuffer);
-}
-
-VkResult DeviceDriver::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const
-{
- return m_vk.createRenderPass(device, pCreateInfo, pRenderPass);
+ m_vk.cmdNextSubpass(cmdBuffer, contents);
}
-void DeviceDriver::cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) const
+void DeviceDriver::cmdEndRenderPass (VkCmdBuffer cmdBuffer) const
{
- m_vk.cmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+ m_vk.cmdEndRenderPass(cmdBuffer);
}
-void DeviceDriver::cmdEndRenderPass (VkCmdBuffer cmdBuffer, VkRenderPass renderPass) const
+void DeviceDriver::cmdExecuteCommands (VkCmdBuffer cmdBuffer, deUint32 cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) const
{
- m_vk.cmdEndRenderPass(cmdBuffer, renderPass);
+ m_vk.cmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
}
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-GetPhysicalDeviceInfoFunc getPhysicalDeviceInfo;
-CreateDeviceFunc createDevice;
-DestroyDeviceFunc destroyDevice;
-GetGlobalExtensionInfoFunc getGlobalExtensionInfo;
-GetPhysicalDeviceExtensionInfoFunc getPhysicalDeviceExtensionInfo;
-EnumerateLayersFunc enumerateLayers;
-GetDeviceQueueFunc getDeviceQueue;
-QueueSubmitFunc queueSubmit;
-QueueAddMemReferencesFunc queueAddMemReferences;
-QueueRemoveMemReferencesFunc queueRemoveMemReferences;
-QueueWaitIdleFunc queueWaitIdle;
-DeviceWaitIdleFunc deviceWaitIdle;
-AllocMemoryFunc allocMemory;
-FreeMemoryFunc freeMemory;
-SetMemoryPriorityFunc setMemoryPriority;
-MapMemoryFunc mapMemory;
-UnmapMemoryFunc unmapMemory;
-FlushMappedMemoryFunc flushMappedMemory;
-PinSystemMemoryFunc pinSystemMemory;
-GetMultiDeviceCompatibilityFunc getMultiDeviceCompatibility;
-OpenSharedMemoryFunc openSharedMemory;
-OpenSharedSemaphoreFunc openSharedSemaphore;
-OpenPeerMemoryFunc openPeerMemory;
-OpenPeerImageFunc openPeerImage;
-DestroyObjectFunc destroyObject;
-GetObjectInfoFunc getObjectInfo;
-QueueBindObjectMemoryFunc queueBindObjectMemory;
-QueueBindObjectMemoryRangeFunc queueBindObjectMemoryRange;
-QueueBindImageMemoryRangeFunc queueBindImageMemoryRange;
-CreateFenceFunc createFence;
-ResetFencesFunc resetFences;
-GetFenceStatusFunc getFenceStatus;
-WaitForFencesFunc waitForFences;
-CreateSemaphoreFunc createSemaphore;
-QueueSignalSemaphoreFunc queueSignalSemaphore;
-QueueWaitSemaphoreFunc queueWaitSemaphore;
-CreateEventFunc createEvent;
-GetEventStatusFunc getEventStatus;
-SetEventFunc setEvent;
-ResetEventFunc resetEvent;
-CreateQueryPoolFunc createQueryPool;
-GetQueryPoolResultsFunc getQueryPoolResults;
-GetFormatInfoFunc getFormatInfo;
-CreateBufferFunc createBuffer;
-CreateBufferViewFunc createBufferView;
-CreateImageFunc createImage;
-GetImageSubresourceInfoFunc getImageSubresourceInfo;
-CreateImageViewFunc createImageView;
-CreateColorAttachmentViewFunc createColorAttachmentView;
-CreateDepthStencilViewFunc createDepthStencilView;
-CreateShaderFunc createShader;
-CreateGraphicsPipelineFunc createGraphicsPipeline;
-CreateGraphicsPipelineDerivativeFunc createGraphicsPipelineDerivative;
-CreateComputePipelineFunc createComputePipeline;
-StorePipelineFunc storePipeline;
-LoadPipelineFunc loadPipeline;
-LoadPipelineDerivativeFunc loadPipelineDerivative;
-CreatePipelineLayoutFunc createPipelineLayout;
-CreateSamplerFunc createSampler;
-CreateDescriptorSetLayoutFunc createDescriptorSetLayout;
-BeginDescriptorPoolUpdateFunc beginDescriptorPoolUpdate;
-EndDescriptorPoolUpdateFunc endDescriptorPoolUpdate;
-CreateDescriptorPoolFunc createDescriptorPool;
-ResetDescriptorPoolFunc resetDescriptorPool;
-AllocDescriptorSetsFunc allocDescriptorSets;
-ClearDescriptorSetsFunc clearDescriptorSets;
-UpdateDescriptorsFunc updateDescriptors;
-CreateDynamicViewportStateFunc createDynamicViewportState;
-CreateDynamicRasterStateFunc createDynamicRasterState;
-CreateDynamicColorBlendStateFunc createDynamicColorBlendState;
-CreateDynamicDepthStencilStateFunc createDynamicDepthStencilState;
-CreateCommandBufferFunc createCommandBuffer;
-BeginCommandBufferFunc beginCommandBuffer;
-EndCommandBufferFunc endCommandBuffer;
-ResetCommandBufferFunc resetCommandBuffer;
-CmdBindPipelineFunc cmdBindPipeline;
-CmdBindDynamicStateObjectFunc cmdBindDynamicStateObject;
-CmdBindDescriptorSetsFunc cmdBindDescriptorSets;
-CmdBindIndexBufferFunc cmdBindIndexBuffer;
-CmdBindVertexBuffersFunc cmdBindVertexBuffers;
-CmdDrawFunc cmdDraw;
-CmdDrawIndexedFunc cmdDrawIndexed;
-CmdDrawIndirectFunc cmdDrawIndirect;
-CmdDrawIndexedIndirectFunc cmdDrawIndexedIndirect;
-CmdDispatchFunc cmdDispatch;
-CmdDispatchIndirectFunc cmdDispatchIndirect;
-CmdCopyBufferFunc cmdCopyBuffer;
-CmdCopyImageFunc cmdCopyImage;
-CmdBlitImageFunc cmdBlitImage;
-CmdCopyBufferToImageFunc cmdCopyBufferToImage;
-CmdCopyImageToBufferFunc cmdCopyImageToBuffer;
-CmdCloneImageDataFunc cmdCloneImageData;
-CmdUpdateBufferFunc cmdUpdateBuffer;
-CmdFillBufferFunc cmdFillBuffer;
-CmdClearColorImageFunc cmdClearColorImage;
-CmdClearDepthStencilFunc cmdClearDepthStencil;
-CmdResolveImageFunc cmdResolveImage;
-CmdSetEventFunc cmdSetEvent;
-CmdResetEventFunc cmdResetEvent;
-CmdWaitEventsFunc cmdWaitEvents;
-CmdPipelineBarrierFunc cmdPipelineBarrier;
-CmdBeginQueryFunc cmdBeginQuery;
-CmdEndQueryFunc cmdEndQuery;
-CmdResetQueryPoolFunc cmdResetQueryPool;
-CmdWriteTimestampFunc cmdWriteTimestamp;
-CmdCopyQueryPoolResultsFunc cmdCopyQueryPoolResults;
-CmdInitAtomicCountersFunc cmdInitAtomicCounters;
-CmdLoadAtomicCountersFunc cmdLoadAtomicCounters;
-CmdSaveAtomicCountersFunc cmdSaveAtomicCounters;
-CreateFramebufferFunc createFramebuffer;
-CreateRenderPassFunc createRenderPass;
-CmdBeginRenderPassFunc cmdBeginRenderPass;
-CmdEndRenderPassFunc cmdEndRenderPass;
+DestroyDeviceFunc destroyDevice;
+GetGlobalExtensionPropertiesFunc getGlobalExtensionProperties;
+GetPhysicalDeviceExtensionPropertiesFunc getPhysicalDeviceExtensionProperties;
+GetGlobalLayerPropertiesFunc getGlobalLayerProperties;
+GetPhysicalDeviceLayerPropertiesFunc getPhysicalDeviceLayerProperties;
+GetDeviceQueueFunc getDeviceQueue;
+QueueSubmitFunc queueSubmit;
+QueueWaitIdleFunc queueWaitIdle;
+DeviceWaitIdleFunc deviceWaitIdle;
+AllocMemoryFunc allocMemory;
+FreeMemoryFunc freeMemory;
+MapMemoryFunc mapMemory;
+UnmapMemoryFunc unmapMemory;
+FlushMappedMemoryRangesFunc flushMappedMemoryRanges;
+InvalidateMappedMemoryRangesFunc invalidateMappedMemoryRanges;
+GetDeviceMemoryCommitmentFunc getDeviceMemoryCommitment;
+BindBufferMemoryFunc bindBufferMemory;
+BindImageMemoryFunc bindImageMemory;
+GetBufferMemoryRequirementsFunc getBufferMemoryRequirements;
+GetImageMemoryRequirementsFunc getImageMemoryRequirements;
+GetImageSparseMemoryRequirementsFunc getImageSparseMemoryRequirements;
+GetPhysicalDeviceSparseImageFormatPropertiesFunc getPhysicalDeviceSparseImageFormatProperties;
+QueueBindSparseBufferMemoryFunc queueBindSparseBufferMemory;
+QueueBindSparseImageOpaqueMemoryFunc queueBindSparseImageOpaqueMemory;
+QueueBindSparseImageMemoryFunc queueBindSparseImageMemory;
+CreateFenceFunc createFence;
+DestroyFenceFunc destroyFence;
+ResetFencesFunc resetFences;
+GetFenceStatusFunc getFenceStatus;
+WaitForFencesFunc waitForFences;
+CreateSemaphoreFunc createSemaphore;
+DestroySemaphoreFunc destroySemaphore;
+QueueSignalSemaphoreFunc queueSignalSemaphore;
+QueueWaitSemaphoreFunc queueWaitSemaphore;
+CreateEventFunc createEvent;
+DestroyEventFunc destroyEvent;
+GetEventStatusFunc getEventStatus;
+SetEventFunc setEvent;
+ResetEventFunc resetEvent;
+CreateQueryPoolFunc createQueryPool;
+DestroyQueryPoolFunc destroyQueryPool;
+GetQueryPoolResultsFunc getQueryPoolResults;
+CreateBufferFunc createBuffer;
+DestroyBufferFunc destroyBuffer;
+CreateBufferViewFunc createBufferView;
+DestroyBufferViewFunc destroyBufferView;
+CreateImageFunc createImage;
+DestroyImageFunc destroyImage;
+GetImageSubresourceLayoutFunc getImageSubresourceLayout;
+CreateImageViewFunc createImageView;
+DestroyImageViewFunc destroyImageView;
+CreateAttachmentViewFunc createAttachmentView;
+DestroyAttachmentViewFunc destroyAttachmentView;
+CreateShaderModuleFunc createShaderModule;
+DestroyShaderModuleFunc destroyShaderModule;
+CreateShaderFunc createShader;
+DestroyShaderFunc destroyShader;
+CreatePipelineCacheFunc createPipelineCache;
+DestroyPipelineCacheFunc destroyPipelineCache;
+GetPipelineCacheSizeFunc getPipelineCacheSize;
+GetPipelineCacheDataFunc getPipelineCacheData;
+MergePipelineCachesFunc mergePipelineCaches;
+CreateGraphicsPipelinesFunc createGraphicsPipelines;
+CreateComputePipelinesFunc createComputePipelines;
+DestroyPipelineFunc destroyPipeline;
+CreatePipelineLayoutFunc createPipelineLayout;
+DestroyPipelineLayoutFunc destroyPipelineLayout;
+CreateSamplerFunc createSampler;
+DestroySamplerFunc destroySampler;
+CreateDescriptorSetLayoutFunc createDescriptorSetLayout;
+DestroyDescriptorSetLayoutFunc destroyDescriptorSetLayout;
+CreateDescriptorPoolFunc createDescriptorPool;
+DestroyDescriptorPoolFunc destroyDescriptorPool;
+ResetDescriptorPoolFunc resetDescriptorPool;
+AllocDescriptorSetsFunc allocDescriptorSets;
+UpdateDescriptorSetsFunc updateDescriptorSets;
+CreateDynamicViewportStateFunc createDynamicViewportState;
+DestroyDynamicViewportStateFunc destroyDynamicViewportState;
+CreateDynamicRasterStateFunc createDynamicRasterState;
+DestroyDynamicRasterStateFunc destroyDynamicRasterState;
+CreateDynamicColorBlendStateFunc createDynamicColorBlendState;
+DestroyDynamicColorBlendStateFunc destroyDynamicColorBlendState;
+CreateDynamicDepthStencilStateFunc createDynamicDepthStencilState;
+DestroyDynamicDepthStencilStateFunc destroyDynamicDepthStencilState;
+CreateFramebufferFunc createFramebuffer;
+DestroyFramebufferFunc destroyFramebuffer;
+CreateRenderPassFunc createRenderPass;
+DestroyRenderPassFunc destroyRenderPass;
+GetRenderAreaGranularityFunc getRenderAreaGranularity;
+CreateCommandPoolFunc createCommandPool;
+DestroyCommandPoolFunc destroyCommandPool;
+ResetCommandPoolFunc resetCommandPool;
+CreateCommandBufferFunc createCommandBuffer;
+DestroyCommandBufferFunc destroyCommandBuffer;
+BeginCommandBufferFunc beginCommandBuffer;
+EndCommandBufferFunc endCommandBuffer;
+ResetCommandBufferFunc resetCommandBuffer;
+CmdBindPipelineFunc cmdBindPipeline;
+CmdBindDynamicViewportStateFunc cmdBindDynamicViewportState;
+CmdBindDynamicRasterStateFunc cmdBindDynamicRasterState;
+CmdBindDynamicColorBlendStateFunc cmdBindDynamicColorBlendState;
+CmdBindDynamicDepthStencilStateFunc cmdBindDynamicDepthStencilState;
+CmdBindDescriptorSetsFunc cmdBindDescriptorSets;
+CmdBindIndexBufferFunc cmdBindIndexBuffer;
+CmdBindVertexBuffersFunc cmdBindVertexBuffers;
+CmdDrawFunc cmdDraw;
+CmdDrawIndexedFunc cmdDrawIndexed;
+CmdDrawIndirectFunc cmdDrawIndirect;
+CmdDrawIndexedIndirectFunc cmdDrawIndexedIndirect;
+CmdDispatchFunc cmdDispatch;
+CmdDispatchIndirectFunc cmdDispatchIndirect;
+CmdCopyBufferFunc cmdCopyBuffer;
+CmdCopyImageFunc cmdCopyImage;
+CmdBlitImageFunc cmdBlitImage;
+CmdCopyBufferToImageFunc cmdCopyBufferToImage;
+CmdCopyImageToBufferFunc cmdCopyImageToBuffer;
+CmdUpdateBufferFunc cmdUpdateBuffer;
+CmdFillBufferFunc cmdFillBuffer;
+CmdClearColorImageFunc cmdClearColorImage;
+CmdClearDepthStencilImageFunc cmdClearDepthStencilImage;
+CmdClearColorAttachmentFunc cmdClearColorAttachment;
+CmdClearDepthStencilAttachmentFunc cmdClearDepthStencilAttachment;
+CmdResolveImageFunc cmdResolveImage;
+CmdSetEventFunc cmdSetEvent;
+CmdResetEventFunc cmdResetEvent;
+CmdWaitEventsFunc cmdWaitEvents;
+CmdPipelineBarrierFunc cmdPipelineBarrier;
+CmdBeginQueryFunc cmdBeginQuery;
+CmdEndQueryFunc cmdEndQuery;
+CmdResetQueryPoolFunc cmdResetQueryPool;
+CmdWriteTimestampFunc cmdWriteTimestamp;
+CmdCopyQueryPoolResultsFunc cmdCopyQueryPoolResults;
+CmdPushConstantsFunc cmdPushConstants;
+CmdBeginRenderPassFunc cmdBeginRenderPass;
+CmdNextSubpassFunc cmdNextSubpass;
+CmdEndRenderPassFunc cmdEndRenderPass;
+CmdExecuteCommandsFunc cmdExecuteCommands;
*//*--------------------------------------------------------------------*/
#include "vkDeviceUtil.hpp"
+#include "vkQueryUtil.hpp"
#include "tcuCommandLine.hpp"
using std::vector;
-Move<VkInstanceT> createDefaultInstance (const PlatformInterface& vkPlatform)
+Move<VkInstance> createDefaultInstance (const PlatformInterface& vkPlatform)
{
const struct VkApplicationInfo appInfo =
{
};
const struct VkInstanceCreateInfo instanceInfo =
{
- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
&appInfo, // const VkApplicationInfo* pAppInfo;
DE_NULL, // const VkAllocCallbacks* pAllocCb;
+ 0u, // deUint32 layerCount;
+ DE_NULL, // const char*const* ppEnabledLayerNames;
0u, // deUint32 extensionCount;
DE_NULL // const char*const* ppEnabledExtensionNames;
};
return createInstance(vkPlatform, &instanceInfo);
}
-VkPhysicalDevice chooseDevice (const PlatformInterface& vkPlatform, VkInstance instance, const tcu::CommandLine& cmdLine)
+VkPhysicalDevice chooseDevice (const InstanceInterface& vkInstance, VkInstance instance, const tcu::CommandLine& cmdLine)
{
- vector<VkPhysicalDevice> devices;
- deUint32 numDevices = 0;
+ const vector<VkPhysicalDevice> devices = enumeratePhysicalDevices(vkInstance, instance);
- VK_CHECK(vkPlatform.enumeratePhysicalDevices(instance, &numDevices, DE_NULL));
-
- if (numDevices > 0)
- {
- devices.resize(numDevices);
- VK_CHECK(vkPlatform.enumeratePhysicalDevices(instance, &numDevices, &devices[0]));
-
- if (numDevices != devices.size())
- TCU_FAIL("Number of devices changed between queries");
+ if (devices.empty())
+ TCU_THROW(NotSupportedError, "No Vulkan devices available");
- if (!de::inBounds(cmdLine.getVKDeviceId(), 1, (int)devices.size()+1))
- TCU_THROW(InternalError, "Invalid --deqp-vk-device-id");
+ if (!de::inBounds(cmdLine.getVKDeviceId(), 1, (int)devices.size()+1))
+ TCU_THROW(InternalError, "Invalid --deqp-vk-device-id");
- return devices[(size_t)(cmdLine.getVKDeviceId()-1)];
- }
- else
- TCU_THROW(NotSupportedError, "No Vulkan devices available");
+ return devices[(size_t)(cmdLine.getVKDeviceId()-1)];
}
} // vk
namespace vk
{
-Move<VkInstanceT> createDefaultInstance (const PlatformInterface& vkPlatform);
-VkPhysicalDevice chooseDevice (const PlatformInterface& vkPlatform, VkInstance instance, const tcu::CommandLine& cmdLine);
+Move<VkInstance> createDefaultInstance (const PlatformInterface& vkPlatform);
+VkPhysicalDevice chooseDevice (const InstanceInterface& vkInstance, VkInstance instance, const tcu::CommandLine& cmdLine);
} // vk
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateInstanceFunc) (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyInstanceFunc) (VkInstance instance);
-typedef VK_APICALL VkResult (VK_APIENTRY* EnumeratePhysicalDevicesFunc) (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceInfoFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL FunctionPtr (VK_APIENTRY* GetProcAddrFunc) (VkPhysicalDevice physicalDevice, const char* pName);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDeviceFunc) (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDeviceFunc) (VkDevice device);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetGlobalExtensionInfoFunc) (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceExtensionInfoFunc) (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL VkResult (VK_APIENTRY* EnumerateLayersFunc) (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetDeviceQueueFunc) (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueSubmitFunc) (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueAddMemReferencesFunc) (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueRemoveMemReferencesFunc) (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueWaitIdleFunc) (VkQueue queue);
-typedef VK_APICALL VkResult (VK_APIENTRY* DeviceWaitIdleFunc) (VkDevice device);
-typedef VK_APICALL VkResult (VK_APIENTRY* AllocMemoryFunc) (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
-typedef VK_APICALL VkResult (VK_APIENTRY* FreeMemoryFunc) (VkDevice device, VkDeviceMemory mem);
-typedef VK_APICALL VkResult (VK_APIENTRY* SetMemoryPriorityFunc) (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority);
-typedef VK_APICALL VkResult (VK_APIENTRY* MapMemoryFunc) (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
-typedef VK_APICALL VkResult (VK_APIENTRY* UnmapMemoryFunc) (VkDevice device, VkDeviceMemory mem);
-typedef VK_APICALL VkResult (VK_APIENTRY* FlushMappedMemoryFunc) (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size);
-typedef VK_APICALL VkResult (VK_APIENTRY* PinSystemMemoryFunc) (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetMultiDeviceCompatibilityFunc) (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo);
-typedef VK_APICALL VkResult (VK_APIENTRY* OpenSharedMemoryFunc) (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem);
-typedef VK_APICALL VkResult (VK_APIENTRY* OpenSharedSemaphoreFunc) (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore);
-typedef VK_APICALL VkResult (VK_APIENTRY* OpenPeerMemoryFunc) (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem);
-typedef VK_APICALL VkResult (VK_APIENTRY* OpenPeerImageFunc) (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem);
-typedef VK_APICALL VkResult (VK_APIENTRY* DestroyObjectFunc) (VkDevice device, VkObjectType objType, VkObject object);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetObjectInfoFunc) (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindObjectMemoryFunc) (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindObjectMemoryRangeFunc) (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindImageMemoryRangeFunc) (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateFenceFunc) (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
-typedef VK_APICALL VkResult (VK_APIENTRY* ResetFencesFunc) (VkDevice device, deUint32 fenceCount, VkFence* pFences);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetFenceStatusFunc) (VkDevice device, VkFence fence);
-typedef VK_APICALL VkResult (VK_APIENTRY* WaitForFencesFunc) (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateSemaphoreFunc) (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueSignalSemaphoreFunc) (VkQueue queue, VkSemaphore semaphore);
-typedef VK_APICALL VkResult (VK_APIENTRY* QueueWaitSemaphoreFunc) (VkQueue queue, VkSemaphore semaphore);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateEventFunc) (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetEventStatusFunc) (VkDevice device, VkEvent event);
-typedef VK_APICALL VkResult (VK_APIENTRY* SetEventFunc) (VkDevice device, VkEvent event);
-typedef VK_APICALL VkResult (VK_APIENTRY* ResetEventFunc) (VkDevice device, VkEvent event);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateQueryPoolFunc) (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetQueryPoolResultsFunc) (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetFormatInfoFunc) (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferFunc) (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferViewFunc) (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageFunc) (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
-typedef VK_APICALL VkResult (VK_APIENTRY* GetImageSubresourceInfoFunc) (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageViewFunc) (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateColorAttachmentViewFunc) (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDepthStencilViewFunc) (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateShaderFunc) (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateGraphicsPipelineFunc) (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateGraphicsPipelineDerivativeFunc) (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateComputePipelineFunc) (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
-typedef VK_APICALL VkResult (VK_APIENTRY* StorePipelineFunc) (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData);
-typedef VK_APICALL VkResult (VK_APIENTRY* LoadPipelineFunc) (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline);
-typedef VK_APICALL VkResult (VK_APIENTRY* LoadPipelineDerivativeFunc) (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreatePipelineLayoutFunc) (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateSamplerFunc) (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorSetLayoutFunc) (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
-typedef VK_APICALL VkResult (VK_APIENTRY* BeginDescriptorPoolUpdateFunc) (VkDevice device, VkDescriptorUpdateMode updateMode);
-typedef VK_APICALL VkResult (VK_APIENTRY* EndDescriptorPoolUpdateFunc) (VkDevice device, VkCmdBuffer cmd);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorPoolFunc) (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* ResetDescriptorPoolFunc) (VkDevice device, VkDescriptorPool descriptorPool);
-typedef VK_APICALL VkResult (VK_APIENTRY* AllocDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount);
-typedef VK_APICALL void (VK_APIENTRY* ClearDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets);
-typedef VK_APICALL void (VK_APIENTRY* UpdateDescriptorsFunc) (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicViewportStateFunc) (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicRasterStateFunc) (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicColorBlendStateFunc) (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicDepthStencilStateFunc) (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateCommandBufferFunc) (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* BeginCommandBufferFunc) (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
-typedef VK_APICALL VkResult (VK_APIENTRY* EndCommandBufferFunc) (VkCmdBuffer cmdBuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* ResetCommandBufferFunc) (VkCmdBuffer cmdBuffer);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindPipelineFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicStateObjectFunc) (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindDescriptorSetsFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindIndexBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-typedef VK_APICALL void (VK_APIENTRY* CmdBindVertexBuffersFunc) (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-typedef VK_APICALL void (VK_APIENTRY* CmdDrawFunc) (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount);
-typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedFunc) (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount);
-typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride);
-typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride);
-typedef VK_APICALL void (VK_APIENTRY* CmdDispatchFunc) (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z);
-typedef VK_APICALL void (VK_APIENTRY* CmdDispatchIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
-typedef VK_APICALL void (VK_APIENTRY* CmdCopyBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions);
-typedef VK_APICALL void (VK_APIENTRY* CmdCopyImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions);
-typedef VK_APICALL void (VK_APIENTRY* CmdBlitImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions);
-typedef VK_APICALL void (VK_APIENTRY* CmdCopyBufferToImageFunc) (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions);
-typedef VK_APICALL void (VK_APIENTRY* CmdCopyImageToBufferFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions);
-typedef VK_APICALL void (VK_APIENTRY* CmdCloneImageDataFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout);
-typedef VK_APICALL void (VK_APIENTRY* CmdUpdateBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData);
-typedef VK_APICALL void (VK_APIENTRY* CmdFillBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data);
-typedef VK_APICALL void (VK_APIENTRY* CmdClearColorImageFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
-typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
-typedef VK_APICALL void (VK_APIENTRY* CmdResolveImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions);
-typedef VK_APICALL void (VK_APIENTRY* CmdSetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
-typedef VK_APICALL void (VK_APIENTRY* CmdResetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
-typedef VK_APICALL void (VK_APIENTRY* CmdWaitEventsFunc) (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers);
-typedef VK_APICALL void (VK_APIENTRY* CmdPipelineBarrierFunc) (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers);
-typedef VK_APICALL void (VK_APIENTRY* CmdBeginQueryFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags);
-typedef VK_APICALL void (VK_APIENTRY* CmdEndQueryFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot);
-typedef VK_APICALL void (VK_APIENTRY* CmdResetQueryPoolFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount);
-typedef VK_APICALL void (VK_APIENTRY* CmdWriteTimestampFunc) (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
-typedef VK_APICALL void (VK_APIENTRY* CmdCopyQueryPoolResultsFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
-typedef VK_APICALL void (VK_APIENTRY* CmdInitAtomicCountersFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData);
-typedef VK_APICALL void (VK_APIENTRY* CmdLoadAtomicCountersFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset);
-typedef VK_APICALL void (VK_APIENTRY* CmdSaveAtomicCountersFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateFramebufferFunc) (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
-typedef VK_APICALL VkResult (VK_APIENTRY* CreateRenderPassFunc) (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
-typedef VK_APICALL void (VK_APIENTRY* CmdBeginRenderPassFunc) (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin);
-typedef VK_APICALL void (VK_APIENTRY* CmdEndRenderPassFunc) (VkCmdBuffer cmdBuffer, VkRenderPass renderPass);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateInstanceFunc) (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyInstanceFunc) (VkInstance instance);
+typedef VK_APICALL VkResult (VK_APIENTRY* EnumeratePhysicalDevicesFunc) (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceFeaturesFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceFormatPropertiesFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceImageFormatPropertiesFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceLimitsFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDevicePropertiesFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceQueueCountFunc) (VkPhysicalDevice physicalDevice, deUint32* pCount);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceQueuePropertiesFunc) (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceMemoryPropertiesFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+typedef VK_APICALL PFN_vkVoidFunction (VK_APIENTRY* GetInstanceProcAddrFunc) (VkInstance instance, const char* pName);
+typedef VK_APICALL PFN_vkVoidFunction (VK_APIENTRY* GetDeviceProcAddrFunc) (VkDevice device, const char* pName);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDeviceFunc) (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDeviceFunc) (VkDevice device);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetGlobalExtensionPropertiesFunc) (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceExtensionPropertiesFunc) (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetGlobalLayerPropertiesFunc) (deUint32* pCount, VkLayerProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceLayerPropertiesFunc) (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetDeviceQueueFunc) (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueSubmitFunc) (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueWaitIdleFunc) (VkQueue queue);
+typedef VK_APICALL VkResult (VK_APIENTRY* DeviceWaitIdleFunc) (VkDevice device);
+typedef VK_APICALL VkResult (VK_APIENTRY* AllocMemoryFunc) (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
+typedef VK_APICALL VkResult (VK_APIENTRY* FreeMemoryFunc) (VkDevice device, VkDeviceMemory mem);
+typedef VK_APICALL VkResult (VK_APIENTRY* MapMemoryFunc) (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+typedef VK_APICALL VkResult (VK_APIENTRY* UnmapMemoryFunc) (VkDevice device, VkDeviceMemory mem);
+typedef VK_APICALL VkResult (VK_APIENTRY* FlushMappedMemoryRangesFunc) (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges);
+typedef VK_APICALL VkResult (VK_APIENTRY* InvalidateMappedMemoryRangesFunc) (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetDeviceMemoryCommitmentFunc) (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+typedef VK_APICALL VkResult (VK_APIENTRY* BindBufferMemoryFunc) (VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VK_APICALL VkResult (VK_APIENTRY* BindImageMemoryFunc) (VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetBufferMemoryRequirementsFunc) (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetImageMemoryRequirementsFunc) (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetImageSparseMemoryRequirementsFunc) (VkDevice device, VkImage image, deUint32* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPhysicalDeviceSparseImageFormatPropertiesFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, deUint32 samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pNumProperties, VkSparseImageFormatProperties* pProperties);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindSparseBufferMemoryFunc) (VkQueue queue, VkBuffer buffer, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindSparseImageOpaqueMemoryFunc) (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueBindSparseImageMemoryFunc) (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateFenceFunc) (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyFenceFunc) (VkDevice device, VkFence fence);
+typedef VK_APICALL VkResult (VK_APIENTRY* ResetFencesFunc) (VkDevice device, deUint32 fenceCount, const VkFence* pFences);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetFenceStatusFunc) (VkDevice device, VkFence fence);
+typedef VK_APICALL VkResult (VK_APIENTRY* WaitForFencesFunc) (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateSemaphoreFunc) (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroySemaphoreFunc) (VkDevice device, VkSemaphore semaphore);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueSignalSemaphoreFunc) (VkQueue queue, VkSemaphore semaphore);
+typedef VK_APICALL VkResult (VK_APIENTRY* QueueWaitSemaphoreFunc) (VkQueue queue, VkSemaphore semaphore);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateEventFunc) (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyEventFunc) (VkDevice device, VkEvent event);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetEventStatusFunc) (VkDevice device, VkEvent event);
+typedef VK_APICALL VkResult (VK_APIENTRY* SetEventFunc) (VkDevice device, VkEvent event);
+typedef VK_APICALL VkResult (VK_APIENTRY* ResetEventFunc) (VkDevice device, VkEvent event);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateQueryPoolFunc) (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyQueryPoolFunc) (VkDevice device, VkQueryPool queryPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetQueryPoolResultsFunc) (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferFunc) (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyBufferFunc) (VkDevice device, VkBuffer buffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateBufferViewFunc) (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyBufferViewFunc) (VkDevice device, VkBufferView bufferView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageFunc) (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyImageFunc) (VkDevice device, VkImage image);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetImageSubresourceLayoutFunc) (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateImageViewFunc) (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyImageViewFunc) (VkDevice device, VkImageView imageView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateAttachmentViewFunc) (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyAttachmentViewFunc) (VkDevice device, VkAttachmentView attachmentView);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateShaderModuleFunc) (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyShaderModuleFunc) (VkDevice device, VkShaderModule shaderModule);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateShaderFunc) (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyShaderFunc) (VkDevice device, VkShader shader);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreatePipelineCacheFunc) (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyPipelineCacheFunc) (VkDevice device, VkPipelineCache pipelineCache);
+typedef VK_APICALL deUintptr (VK_APIENTRY* GetPipelineCacheSizeFunc) (VkDevice device, VkPipelineCache pipelineCache);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetPipelineCacheDataFunc) (VkDevice device, VkPipelineCache pipelineCache, void* pData);
+typedef VK_APICALL VkResult (VK_APIENTRY* MergePipelineCachesFunc) (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateGraphicsPipelinesFunc) (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateComputePipelinesFunc) (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyPipelineFunc) (VkDevice device, VkPipeline pipeline);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreatePipelineLayoutFunc) (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyPipelineLayoutFunc) (VkDevice device, VkPipelineLayout pipelineLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateSamplerFunc) (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroySamplerFunc) (VkDevice device, VkSampler sampler);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorSetLayoutFunc) (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDescriptorSetLayoutFunc) (VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDescriptorPoolFunc) (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDescriptorPoolFunc) (VkDevice device, VkDescriptorPool descriptorPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* ResetDescriptorPoolFunc) (VkDevice device, VkDescriptorPool descriptorPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* AllocDescriptorSetsFunc) (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount);
+typedef VK_APICALL VkResult (VK_APIENTRY* UpdateDescriptorSetsFunc) (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicViewportStateFunc) (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicViewportStateFunc) (VkDevice device, VkDynamicViewportState dynamicViewportState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicRasterStateFunc) (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicRasterStateFunc) (VkDevice device, VkDynamicRasterState dynamicRasterState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicColorBlendStateFunc) (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicColorBlendStateFunc) (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateDynamicDepthStencilStateFunc) (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyDynamicDepthStencilStateFunc) (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateFramebufferFunc) (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyFramebufferFunc) (VkDevice device, VkFramebuffer framebuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateRenderPassFunc) (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyRenderPassFunc) (VkDevice device, VkRenderPass renderPass);
+typedef VK_APICALL VkResult (VK_APIENTRY* GetRenderAreaGranularityFunc) (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateCommandPoolFunc) (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyCommandPoolFunc) (VkDevice device, VkCmdPool cmdPool);
+typedef VK_APICALL VkResult (VK_APIENTRY* ResetCommandPoolFunc) (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+typedef VK_APICALL VkResult (VK_APIENTRY* CreateCommandBufferFunc) (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* DestroyCommandBufferFunc) (VkDevice device, VkCmdBuffer commandBuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* BeginCommandBufferFunc) (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
+typedef VK_APICALL VkResult (VK_APIENTRY* EndCommandBufferFunc) (VkCmdBuffer cmdBuffer);
+typedef VK_APICALL VkResult (VK_APIENTRY* ResetCommandBufferFunc) (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindPipelineFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicViewportStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicRasterStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicColorBlendStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDynamicDepthStencilStateFunc) (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindDescriptorSetsFunc) (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindIndexBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+typedef VK_APICALL void (VK_APIENTRY* CmdBindVertexBuffersFunc) (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+typedef VK_APICALL void (VK_APIENTRY* CmdDrawFunc) (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount);
+typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedFunc) (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount);
+typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride);
+typedef VK_APICALL void (VK_APIENTRY* CmdDrawIndexedIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride);
+typedef VK_APICALL void (VK_APIENTRY* CmdDispatchFunc) (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z);
+typedef VK_APICALL void (VK_APIENTRY* CmdDispatchIndirectFunc) (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdBlitImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkTexFilter filter);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyBufferToImageFunc) (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyImageToBufferFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdUpdateBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData);
+typedef VK_APICALL void (VK_APIENTRY* CmdFillBufferFunc) (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearColorImageFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilImageFunc) (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearColorAttachmentFunc) (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects);
+typedef VK_APICALL void (VK_APIENTRY* CmdClearDepthStencilAttachmentFunc) (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects);
+typedef VK_APICALL void (VK_APIENTRY* CmdResolveImageFunc) (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions);
+typedef VK_APICALL void (VK_APIENTRY* CmdSetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef VK_APICALL void (VK_APIENTRY* CmdResetEventFunc) (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef VK_APICALL void (VK_APIENTRY* CmdWaitEventsFunc) (VkCmdBuffer cmdBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, deUint32 memBarrierCount, const void* const* ppMemBarriers);
+typedef VK_APICALL void (VK_APIENTRY* CmdPipelineBarrierFunc) (VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, deUint32 memBarrierCount, const void* const* ppMemBarriers);
+typedef VK_APICALL void (VK_APIENTRY* CmdBeginQueryFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags);
+typedef VK_APICALL void (VK_APIENTRY* CmdEndQueryFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot);
+typedef VK_APICALL void (VK_APIENTRY* CmdResetQueryPoolFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount);
+typedef VK_APICALL void (VK_APIENTRY* CmdWriteTimestampFunc) (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
+typedef VK_APICALL void (VK_APIENTRY* CmdCopyQueryPoolResultsFunc) (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+typedef VK_APICALL void (VK_APIENTRY* CmdPushConstantsFunc) (VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 start, deUint32 length, const void* values);
+typedef VK_APICALL void (VK_APIENTRY* CmdBeginRenderPassFunc) (VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+typedef VK_APICALL void (VK_APIENTRY* CmdNextSubpassFunc) (VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
+typedef VK_APICALL void (VK_APIENTRY* CmdEndRenderPassFunc) (VkCmdBuffer cmdBuffer);
+typedef VK_APICALL void (VK_APIENTRY* CmdExecuteCommandsFunc) (VkCmdBuffer cmdBuffer, deUint32 cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
+++ /dev/null
-/* WARNING: This is auto-generated file. Do not modify, since changes will
- * be lost! Modify the generating script instead.
- */
-template<> VkObjectType getObjectType<VkInstanceT> (void) { return VK_OBJECT_TYPE_INSTANCE; }
-template<> VkObjectType getObjectType<VkPhysicalDeviceT> (void) { return VK_OBJECT_TYPE_PHYSICAL_DEVICE; }
-template<> VkObjectType getObjectType<VkDeviceT> (void) { return VK_OBJECT_TYPE_DEVICE; }
-template<> VkObjectType getObjectType<VkQueueT> (void) { return VK_OBJECT_TYPE_QUEUE; }
-template<> VkObjectType getObjectType<VkCmdBufferT> (void) { return VK_OBJECT_TYPE_COMMAND_BUFFER; }
-template<> VkObjectType getObjectType<VkDeviceMemoryT> (void) { return VK_OBJECT_TYPE_DEVICE_MEMORY; }
-template<> VkObjectType getObjectType<VkBufferT> (void) { return VK_OBJECT_TYPE_BUFFER; }
-template<> VkObjectType getObjectType<VkBufferViewT> (void) { return VK_OBJECT_TYPE_BUFFER_VIEW; }
-template<> VkObjectType getObjectType<VkImageT> (void) { return VK_OBJECT_TYPE_IMAGE; }
-template<> VkObjectType getObjectType<VkImageViewT> (void) { return VK_OBJECT_TYPE_IMAGE_VIEW; }
-template<> VkObjectType getObjectType<VkColorAttachmentViewT> (void) { return VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW; }
-template<> VkObjectType getObjectType<VkDepthStencilViewT> (void) { return VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW; }
-template<> VkObjectType getObjectType<VkShaderT> (void) { return VK_OBJECT_TYPE_SHADER; }
-template<> VkObjectType getObjectType<VkPipelineT> (void) { return VK_OBJECT_TYPE_PIPELINE; }
-template<> VkObjectType getObjectType<VkPipelineLayoutT> (void) { return VK_OBJECT_TYPE_PIPELINE_LAYOUT; }
-template<> VkObjectType getObjectType<VkSamplerT> (void) { return VK_OBJECT_TYPE_SAMPLER; }
-template<> VkObjectType getObjectType<VkDescriptorSetT> (void) { return VK_OBJECT_TYPE_DESCRIPTOR_SET; }
-template<> VkObjectType getObjectType<VkDescriptorSetLayoutT> (void) { return VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; }
-template<> VkObjectType getObjectType<VkDescriptorPoolT> (void) { return VK_OBJECT_TYPE_DESCRIPTOR_POOL; }
-template<> VkObjectType getObjectType<VkDynamicVpStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_VP_STATE; }
-template<> VkObjectType getObjectType<VkDynamicRsStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_RS_STATE; }
-template<> VkObjectType getObjectType<VkDynamicCbStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_CB_STATE; }
-template<> VkObjectType getObjectType<VkDynamicDsStateT> (void) { return VK_OBJECT_TYPE_DYNAMIC_DS_STATE; }
-template<> VkObjectType getObjectType<VkFenceT> (void) { return VK_OBJECT_TYPE_FENCE; }
-template<> VkObjectType getObjectType<VkSemaphoreT> (void) { return VK_OBJECT_TYPE_SEMAPHORE; }
-template<> VkObjectType getObjectType<VkEventT> (void) { return VK_OBJECT_TYPE_EVENT; }
-template<> VkObjectType getObjectType<VkQueryPoolT> (void) { return VK_OBJECT_TYPE_QUERY_POOL; }
-template<> VkObjectType getObjectType<VkFramebufferT> (void) { return VK_OBJECT_TYPE_FRAMEBUFFER; }
-template<> VkObjectType getObjectType<VkRenderPassT> (void) { return VK_OBJECT_TYPE_RENDER_PASS; }
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+enum HandleType
+{
+ HANDLE_TYPE_INSTANCE = 0,
+ HANDLE_TYPE_PHYSICAL_DEVICE,
+ HANDLE_TYPE_DEVICE,
+ HANDLE_TYPE_QUEUE,
+ HANDLE_TYPE_CMD_BUFFER,
+ HANDLE_TYPE_FENCE,
+ HANDLE_TYPE_DEVICE_MEMORY,
+ HANDLE_TYPE_BUFFER,
+ HANDLE_TYPE_IMAGE,
+ HANDLE_TYPE_SEMAPHORE,
+ HANDLE_TYPE_EVENT,
+ HANDLE_TYPE_QUERY_POOL,
+ HANDLE_TYPE_BUFFER_VIEW,
+ HANDLE_TYPE_IMAGE_VIEW,
+ HANDLE_TYPE_ATTACHMENT_VIEW,
+ HANDLE_TYPE_SHADER_MODULE,
+ HANDLE_TYPE_SHADER,
+ HANDLE_TYPE_PIPELINE_CACHE,
+ HANDLE_TYPE_PIPELINE_LAYOUT,
+ HANDLE_TYPE_RENDER_PASS,
+ HANDLE_TYPE_PIPELINE,
+ HANDLE_TYPE_DESCRIPTOR_SET_LAYOUT,
+ HANDLE_TYPE_SAMPLER,
+ HANDLE_TYPE_DESCRIPTOR_POOL,
+ HANDLE_TYPE_DESCRIPTOR_SET,
+ HANDLE_TYPE_DYNAMIC_VIEWPORT_STATE,
+ HANDLE_TYPE_DYNAMIC_RASTER_STATE,
+ HANDLE_TYPE_DYNAMIC_COLOR_BLEND_STATE,
+ HANDLE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE,
+ HANDLE_TYPE_FRAMEBUFFER,
+ HANDLE_TYPE_CMD_POOL,
+ HANDLE_TYPE_LAST
+};
+
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-m_vk.getPhysicalDeviceInfo = (GetPhysicalDeviceInfoFunc) GET_PROC_ADDR("vkGetPhysicalDeviceInfo");
-m_vk.createDevice = (CreateDeviceFunc) GET_PROC_ADDR("vkCreateDevice");
-m_vk.destroyDevice = (DestroyDeviceFunc) GET_PROC_ADDR("vkDestroyDevice");
-m_vk.getGlobalExtensionInfo = (GetGlobalExtensionInfoFunc) GET_PROC_ADDR("vkGetGlobalExtensionInfo");
-m_vk.getPhysicalDeviceExtensionInfo = (GetPhysicalDeviceExtensionInfoFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExtensionInfo");
-m_vk.enumerateLayers = (EnumerateLayersFunc) GET_PROC_ADDR("vkEnumerateLayers");
-m_vk.getDeviceQueue = (GetDeviceQueueFunc) GET_PROC_ADDR("vkGetDeviceQueue");
-m_vk.queueSubmit = (QueueSubmitFunc) GET_PROC_ADDR("vkQueueSubmit");
-m_vk.queueAddMemReferences = (QueueAddMemReferencesFunc) GET_PROC_ADDR("vkQueueAddMemReferences");
-m_vk.queueRemoveMemReferences = (QueueRemoveMemReferencesFunc) GET_PROC_ADDR("vkQueueRemoveMemReferences");
-m_vk.queueWaitIdle = (QueueWaitIdleFunc) GET_PROC_ADDR("vkQueueWaitIdle");
-m_vk.deviceWaitIdle = (DeviceWaitIdleFunc) GET_PROC_ADDR("vkDeviceWaitIdle");
-m_vk.allocMemory = (AllocMemoryFunc) GET_PROC_ADDR("vkAllocMemory");
-m_vk.freeMemory = (FreeMemoryFunc) GET_PROC_ADDR("vkFreeMemory");
-m_vk.setMemoryPriority = (SetMemoryPriorityFunc) GET_PROC_ADDR("vkSetMemoryPriority");
-m_vk.mapMemory = (MapMemoryFunc) GET_PROC_ADDR("vkMapMemory");
-m_vk.unmapMemory = (UnmapMemoryFunc) GET_PROC_ADDR("vkUnmapMemory");
-m_vk.flushMappedMemory = (FlushMappedMemoryFunc) GET_PROC_ADDR("vkFlushMappedMemory");
-m_vk.pinSystemMemory = (PinSystemMemoryFunc) GET_PROC_ADDR("vkPinSystemMemory");
-m_vk.getMultiDeviceCompatibility = (GetMultiDeviceCompatibilityFunc) GET_PROC_ADDR("vkGetMultiDeviceCompatibility");
-m_vk.openSharedMemory = (OpenSharedMemoryFunc) GET_PROC_ADDR("vkOpenSharedMemory");
-m_vk.openSharedSemaphore = (OpenSharedSemaphoreFunc) GET_PROC_ADDR("vkOpenSharedSemaphore");
-m_vk.openPeerMemory = (OpenPeerMemoryFunc) GET_PROC_ADDR("vkOpenPeerMemory");
-m_vk.openPeerImage = (OpenPeerImageFunc) GET_PROC_ADDR("vkOpenPeerImage");
-m_vk.destroyObject = (DestroyObjectFunc) GET_PROC_ADDR("vkDestroyObject");
-m_vk.getObjectInfo = (GetObjectInfoFunc) GET_PROC_ADDR("vkGetObjectInfo");
-m_vk.queueBindObjectMemory = (QueueBindObjectMemoryFunc) GET_PROC_ADDR("vkQueueBindObjectMemory");
-m_vk.queueBindObjectMemoryRange = (QueueBindObjectMemoryRangeFunc) GET_PROC_ADDR("vkQueueBindObjectMemoryRange");
-m_vk.queueBindImageMemoryRange = (QueueBindImageMemoryRangeFunc) GET_PROC_ADDR("vkQueueBindImageMemoryRange");
-m_vk.createFence = (CreateFenceFunc) GET_PROC_ADDR("vkCreateFence");
-m_vk.resetFences = (ResetFencesFunc) GET_PROC_ADDR("vkResetFences");
-m_vk.getFenceStatus = (GetFenceStatusFunc) GET_PROC_ADDR("vkGetFenceStatus");
-m_vk.waitForFences = (WaitForFencesFunc) GET_PROC_ADDR("vkWaitForFences");
-m_vk.createSemaphore = (CreateSemaphoreFunc) GET_PROC_ADDR("vkCreateSemaphore");
-m_vk.queueSignalSemaphore = (QueueSignalSemaphoreFunc) GET_PROC_ADDR("vkQueueSignalSemaphore");
-m_vk.queueWaitSemaphore = (QueueWaitSemaphoreFunc) GET_PROC_ADDR("vkQueueWaitSemaphore");
-m_vk.createEvent = (CreateEventFunc) GET_PROC_ADDR("vkCreateEvent");
-m_vk.getEventStatus = (GetEventStatusFunc) GET_PROC_ADDR("vkGetEventStatus");
-m_vk.setEvent = (SetEventFunc) GET_PROC_ADDR("vkSetEvent");
-m_vk.resetEvent = (ResetEventFunc) GET_PROC_ADDR("vkResetEvent");
-m_vk.createQueryPool = (CreateQueryPoolFunc) GET_PROC_ADDR("vkCreateQueryPool");
-m_vk.getQueryPoolResults = (GetQueryPoolResultsFunc) GET_PROC_ADDR("vkGetQueryPoolResults");
-m_vk.getFormatInfo = (GetFormatInfoFunc) GET_PROC_ADDR("vkGetFormatInfo");
-m_vk.createBuffer = (CreateBufferFunc) GET_PROC_ADDR("vkCreateBuffer");
-m_vk.createBufferView = (CreateBufferViewFunc) GET_PROC_ADDR("vkCreateBufferView");
-m_vk.createImage = (CreateImageFunc) GET_PROC_ADDR("vkCreateImage");
-m_vk.getImageSubresourceInfo = (GetImageSubresourceInfoFunc) GET_PROC_ADDR("vkGetImageSubresourceInfo");
-m_vk.createImageView = (CreateImageViewFunc) GET_PROC_ADDR("vkCreateImageView");
-m_vk.createColorAttachmentView = (CreateColorAttachmentViewFunc) GET_PROC_ADDR("vkCreateColorAttachmentView");
-m_vk.createDepthStencilView = (CreateDepthStencilViewFunc) GET_PROC_ADDR("vkCreateDepthStencilView");
-m_vk.createShader = (CreateShaderFunc) GET_PROC_ADDR("vkCreateShader");
-m_vk.createGraphicsPipeline = (CreateGraphicsPipelineFunc) GET_PROC_ADDR("vkCreateGraphicsPipeline");
-m_vk.createGraphicsPipelineDerivative = (CreateGraphicsPipelineDerivativeFunc) GET_PROC_ADDR("vkCreateGraphicsPipelineDerivative");
-m_vk.createComputePipeline = (CreateComputePipelineFunc) GET_PROC_ADDR("vkCreateComputePipeline");
-m_vk.storePipeline = (StorePipelineFunc) GET_PROC_ADDR("vkStorePipeline");
-m_vk.loadPipeline = (LoadPipelineFunc) GET_PROC_ADDR("vkLoadPipeline");
-m_vk.loadPipelineDerivative = (LoadPipelineDerivativeFunc) GET_PROC_ADDR("vkLoadPipelineDerivative");
-m_vk.createPipelineLayout = (CreatePipelineLayoutFunc) GET_PROC_ADDR("vkCreatePipelineLayout");
-m_vk.createSampler = (CreateSamplerFunc) GET_PROC_ADDR("vkCreateSampler");
-m_vk.createDescriptorSetLayout = (CreateDescriptorSetLayoutFunc) GET_PROC_ADDR("vkCreateDescriptorSetLayout");
-m_vk.beginDescriptorPoolUpdate = (BeginDescriptorPoolUpdateFunc) GET_PROC_ADDR("vkBeginDescriptorPoolUpdate");
-m_vk.endDescriptorPoolUpdate = (EndDescriptorPoolUpdateFunc) GET_PROC_ADDR("vkEndDescriptorPoolUpdate");
-m_vk.createDescriptorPool = (CreateDescriptorPoolFunc) GET_PROC_ADDR("vkCreateDescriptorPool");
-m_vk.resetDescriptorPool = (ResetDescriptorPoolFunc) GET_PROC_ADDR("vkResetDescriptorPool");
-m_vk.allocDescriptorSets = (AllocDescriptorSetsFunc) GET_PROC_ADDR("vkAllocDescriptorSets");
-m_vk.clearDescriptorSets = (ClearDescriptorSetsFunc) GET_PROC_ADDR("vkClearDescriptorSets");
-m_vk.updateDescriptors = (UpdateDescriptorsFunc) GET_PROC_ADDR("vkUpdateDescriptors");
-m_vk.createDynamicViewportState = (CreateDynamicViewportStateFunc) GET_PROC_ADDR("vkCreateDynamicViewportState");
-m_vk.createDynamicRasterState = (CreateDynamicRasterStateFunc) GET_PROC_ADDR("vkCreateDynamicRasterState");
-m_vk.createDynamicColorBlendState = (CreateDynamicColorBlendStateFunc) GET_PROC_ADDR("vkCreateDynamicColorBlendState");
-m_vk.createDynamicDepthStencilState = (CreateDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkCreateDynamicDepthStencilState");
-m_vk.createCommandBuffer = (CreateCommandBufferFunc) GET_PROC_ADDR("vkCreateCommandBuffer");
-m_vk.beginCommandBuffer = (BeginCommandBufferFunc) GET_PROC_ADDR("vkBeginCommandBuffer");
-m_vk.endCommandBuffer = (EndCommandBufferFunc) GET_PROC_ADDR("vkEndCommandBuffer");
-m_vk.resetCommandBuffer = (ResetCommandBufferFunc) GET_PROC_ADDR("vkResetCommandBuffer");
-m_vk.cmdBindPipeline = (CmdBindPipelineFunc) GET_PROC_ADDR("vkCmdBindPipeline");
-m_vk.cmdBindDynamicStateObject = (CmdBindDynamicStateObjectFunc) GET_PROC_ADDR("vkCmdBindDynamicStateObject");
-m_vk.cmdBindDescriptorSets = (CmdBindDescriptorSetsFunc) GET_PROC_ADDR("vkCmdBindDescriptorSets");
-m_vk.cmdBindIndexBuffer = (CmdBindIndexBufferFunc) GET_PROC_ADDR("vkCmdBindIndexBuffer");
-m_vk.cmdBindVertexBuffers = (CmdBindVertexBuffersFunc) GET_PROC_ADDR("vkCmdBindVertexBuffers");
-m_vk.cmdDraw = (CmdDrawFunc) GET_PROC_ADDR("vkCmdDraw");
-m_vk.cmdDrawIndexed = (CmdDrawIndexedFunc) GET_PROC_ADDR("vkCmdDrawIndexed");
-m_vk.cmdDrawIndirect = (CmdDrawIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndirect");
-m_vk.cmdDrawIndexedIndirect = (CmdDrawIndexedIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirect");
-m_vk.cmdDispatch = (CmdDispatchFunc) GET_PROC_ADDR("vkCmdDispatch");
-m_vk.cmdDispatchIndirect = (CmdDispatchIndirectFunc) GET_PROC_ADDR("vkCmdDispatchIndirect");
-m_vk.cmdCopyBuffer = (CmdCopyBufferFunc) GET_PROC_ADDR("vkCmdCopyBuffer");
-m_vk.cmdCopyImage = (CmdCopyImageFunc) GET_PROC_ADDR("vkCmdCopyImage");
-m_vk.cmdBlitImage = (CmdBlitImageFunc) GET_PROC_ADDR("vkCmdBlitImage");
-m_vk.cmdCopyBufferToImage = (CmdCopyBufferToImageFunc) GET_PROC_ADDR("vkCmdCopyBufferToImage");
-m_vk.cmdCopyImageToBuffer = (CmdCopyImageToBufferFunc) GET_PROC_ADDR("vkCmdCopyImageToBuffer");
-m_vk.cmdCloneImageData = (CmdCloneImageDataFunc) GET_PROC_ADDR("vkCmdCloneImageData");
-m_vk.cmdUpdateBuffer = (CmdUpdateBufferFunc) GET_PROC_ADDR("vkCmdUpdateBuffer");
-m_vk.cmdFillBuffer = (CmdFillBufferFunc) GET_PROC_ADDR("vkCmdFillBuffer");
-m_vk.cmdClearColorImage = (CmdClearColorImageFunc) GET_PROC_ADDR("vkCmdClearColorImage");
-m_vk.cmdClearDepthStencil = (CmdClearDepthStencilFunc) GET_PROC_ADDR("vkCmdClearDepthStencil");
-m_vk.cmdResolveImage = (CmdResolveImageFunc) GET_PROC_ADDR("vkCmdResolveImage");
-m_vk.cmdSetEvent = (CmdSetEventFunc) GET_PROC_ADDR("vkCmdSetEvent");
-m_vk.cmdResetEvent = (CmdResetEventFunc) GET_PROC_ADDR("vkCmdResetEvent");
-m_vk.cmdWaitEvents = (CmdWaitEventsFunc) GET_PROC_ADDR("vkCmdWaitEvents");
-m_vk.cmdPipelineBarrier = (CmdPipelineBarrierFunc) GET_PROC_ADDR("vkCmdPipelineBarrier");
-m_vk.cmdBeginQuery = (CmdBeginQueryFunc) GET_PROC_ADDR("vkCmdBeginQuery");
-m_vk.cmdEndQuery = (CmdEndQueryFunc) GET_PROC_ADDR("vkCmdEndQuery");
-m_vk.cmdResetQueryPool = (CmdResetQueryPoolFunc) GET_PROC_ADDR("vkCmdResetQueryPool");
-m_vk.cmdWriteTimestamp = (CmdWriteTimestampFunc) GET_PROC_ADDR("vkCmdWriteTimestamp");
-m_vk.cmdCopyQueryPoolResults = (CmdCopyQueryPoolResultsFunc) GET_PROC_ADDR("vkCmdCopyQueryPoolResults");
-m_vk.cmdInitAtomicCounters = (CmdInitAtomicCountersFunc) GET_PROC_ADDR("vkCmdInitAtomicCounters");
-m_vk.cmdLoadAtomicCounters = (CmdLoadAtomicCountersFunc) GET_PROC_ADDR("vkCmdLoadAtomicCounters");
-m_vk.cmdSaveAtomicCounters = (CmdSaveAtomicCountersFunc) GET_PROC_ADDR("vkCmdSaveAtomicCounters");
-m_vk.createFramebuffer = (CreateFramebufferFunc) GET_PROC_ADDR("vkCreateFramebuffer");
-m_vk.createRenderPass = (CreateRenderPassFunc) GET_PROC_ADDR("vkCreateRenderPass");
-m_vk.cmdBeginRenderPass = (CmdBeginRenderPassFunc) GET_PROC_ADDR("vkCmdBeginRenderPass");
-m_vk.cmdEndRenderPass = (CmdEndRenderPassFunc) GET_PROC_ADDR("vkCmdEndRenderPass");
+m_vk.destroyDevice = (DestroyDeviceFunc) GET_PROC_ADDR("vkDestroyDevice");
+m_vk.getGlobalExtensionProperties = (GetGlobalExtensionPropertiesFunc) GET_PROC_ADDR("vkGetGlobalExtensionProperties");
+m_vk.getPhysicalDeviceExtensionProperties = (GetPhysicalDeviceExtensionPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExtensionProperties");
+m_vk.getGlobalLayerProperties = (GetGlobalLayerPropertiesFunc) GET_PROC_ADDR("vkGetGlobalLayerProperties");
+m_vk.getPhysicalDeviceLayerProperties = (GetPhysicalDeviceLayerPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceLayerProperties");
+m_vk.getDeviceQueue = (GetDeviceQueueFunc) GET_PROC_ADDR("vkGetDeviceQueue");
+m_vk.queueSubmit = (QueueSubmitFunc) GET_PROC_ADDR("vkQueueSubmit");
+m_vk.queueWaitIdle = (QueueWaitIdleFunc) GET_PROC_ADDR("vkQueueWaitIdle");
+m_vk.deviceWaitIdle = (DeviceWaitIdleFunc) GET_PROC_ADDR("vkDeviceWaitIdle");
+m_vk.allocMemory = (AllocMemoryFunc) GET_PROC_ADDR("vkAllocMemory");
+m_vk.freeMemory = (FreeMemoryFunc) GET_PROC_ADDR("vkFreeMemory");
+m_vk.mapMemory = (MapMemoryFunc) GET_PROC_ADDR("vkMapMemory");
+m_vk.unmapMemory = (UnmapMemoryFunc) GET_PROC_ADDR("vkUnmapMemory");
+m_vk.flushMappedMemoryRanges = (FlushMappedMemoryRangesFunc) GET_PROC_ADDR("vkFlushMappedMemoryRanges");
+m_vk.invalidateMappedMemoryRanges = (InvalidateMappedMemoryRangesFunc) GET_PROC_ADDR("vkInvalidateMappedMemoryRanges");
+m_vk.getDeviceMemoryCommitment = (GetDeviceMemoryCommitmentFunc) GET_PROC_ADDR("vkGetDeviceMemoryCommitment");
+m_vk.bindBufferMemory = (BindBufferMemoryFunc) GET_PROC_ADDR("vkBindBufferMemory");
+m_vk.bindImageMemory = (BindImageMemoryFunc) GET_PROC_ADDR("vkBindImageMemory");
+m_vk.getBufferMemoryRequirements = (GetBufferMemoryRequirementsFunc) GET_PROC_ADDR("vkGetBufferMemoryRequirements");
+m_vk.getImageMemoryRequirements = (GetImageMemoryRequirementsFunc) GET_PROC_ADDR("vkGetImageMemoryRequirements");
+m_vk.getImageSparseMemoryRequirements = (GetImageSparseMemoryRequirementsFunc) GET_PROC_ADDR("vkGetImageSparseMemoryRequirements");
+m_vk.getPhysicalDeviceSparseImageFormatProperties = (GetPhysicalDeviceSparseImageFormatPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSparseImageFormatProperties");
+m_vk.queueBindSparseBufferMemory = (QueueBindSparseBufferMemoryFunc) GET_PROC_ADDR("vkQueueBindSparseBufferMemory");
+m_vk.queueBindSparseImageOpaqueMemory = (QueueBindSparseImageOpaqueMemoryFunc) GET_PROC_ADDR("vkQueueBindSparseImageOpaqueMemory");
+m_vk.queueBindSparseImageMemory = (QueueBindSparseImageMemoryFunc) GET_PROC_ADDR("vkQueueBindSparseImageMemory");
+m_vk.createFence = (CreateFenceFunc) GET_PROC_ADDR("vkCreateFence");
+m_vk.destroyFence = (DestroyFenceFunc) GET_PROC_ADDR("vkDestroyFence");
+m_vk.resetFences = (ResetFencesFunc) GET_PROC_ADDR("vkResetFences");
+m_vk.getFenceStatus = (GetFenceStatusFunc) GET_PROC_ADDR("vkGetFenceStatus");
+m_vk.waitForFences = (WaitForFencesFunc) GET_PROC_ADDR("vkWaitForFences");
+m_vk.createSemaphore = (CreateSemaphoreFunc) GET_PROC_ADDR("vkCreateSemaphore");
+m_vk.destroySemaphore = (DestroySemaphoreFunc) GET_PROC_ADDR("vkDestroySemaphore");
+m_vk.queueSignalSemaphore = (QueueSignalSemaphoreFunc) GET_PROC_ADDR("vkQueueSignalSemaphore");
+m_vk.queueWaitSemaphore = (QueueWaitSemaphoreFunc) GET_PROC_ADDR("vkQueueWaitSemaphore");
+m_vk.createEvent = (CreateEventFunc) GET_PROC_ADDR("vkCreateEvent");
+m_vk.destroyEvent = (DestroyEventFunc) GET_PROC_ADDR("vkDestroyEvent");
+m_vk.getEventStatus = (GetEventStatusFunc) GET_PROC_ADDR("vkGetEventStatus");
+m_vk.setEvent = (SetEventFunc) GET_PROC_ADDR("vkSetEvent");
+m_vk.resetEvent = (ResetEventFunc) GET_PROC_ADDR("vkResetEvent");
+m_vk.createQueryPool = (CreateQueryPoolFunc) GET_PROC_ADDR("vkCreateQueryPool");
+m_vk.destroyQueryPool = (DestroyQueryPoolFunc) GET_PROC_ADDR("vkDestroyQueryPool");
+m_vk.getQueryPoolResults = (GetQueryPoolResultsFunc) GET_PROC_ADDR("vkGetQueryPoolResults");
+m_vk.createBuffer = (CreateBufferFunc) GET_PROC_ADDR("vkCreateBuffer");
+m_vk.destroyBuffer = (DestroyBufferFunc) GET_PROC_ADDR("vkDestroyBuffer");
+m_vk.createBufferView = (CreateBufferViewFunc) GET_PROC_ADDR("vkCreateBufferView");
+m_vk.destroyBufferView = (DestroyBufferViewFunc) GET_PROC_ADDR("vkDestroyBufferView");
+m_vk.createImage = (CreateImageFunc) GET_PROC_ADDR("vkCreateImage");
+m_vk.destroyImage = (DestroyImageFunc) GET_PROC_ADDR("vkDestroyImage");
+m_vk.getImageSubresourceLayout = (GetImageSubresourceLayoutFunc) GET_PROC_ADDR("vkGetImageSubresourceLayout");
+m_vk.createImageView = (CreateImageViewFunc) GET_PROC_ADDR("vkCreateImageView");
+m_vk.destroyImageView = (DestroyImageViewFunc) GET_PROC_ADDR("vkDestroyImageView");
+m_vk.createAttachmentView = (CreateAttachmentViewFunc) GET_PROC_ADDR("vkCreateAttachmentView");
+m_vk.destroyAttachmentView = (DestroyAttachmentViewFunc) GET_PROC_ADDR("vkDestroyAttachmentView");
+m_vk.createShaderModule = (CreateShaderModuleFunc) GET_PROC_ADDR("vkCreateShaderModule");
+m_vk.destroyShaderModule = (DestroyShaderModuleFunc) GET_PROC_ADDR("vkDestroyShaderModule");
+m_vk.createShader = (CreateShaderFunc) GET_PROC_ADDR("vkCreateShader");
+m_vk.destroyShader = (DestroyShaderFunc) GET_PROC_ADDR("vkDestroyShader");
+m_vk.createPipelineCache = (CreatePipelineCacheFunc) GET_PROC_ADDR("vkCreatePipelineCache");
+m_vk.destroyPipelineCache = (DestroyPipelineCacheFunc) GET_PROC_ADDR("vkDestroyPipelineCache");
+m_vk.getPipelineCacheSize = (GetPipelineCacheSizeFunc) GET_PROC_ADDR("vkGetPipelineCacheSize");
+m_vk.getPipelineCacheData = (GetPipelineCacheDataFunc) GET_PROC_ADDR("vkGetPipelineCacheData");
+m_vk.mergePipelineCaches = (MergePipelineCachesFunc) GET_PROC_ADDR("vkMergePipelineCaches");
+m_vk.createGraphicsPipelines = (CreateGraphicsPipelinesFunc) GET_PROC_ADDR("vkCreateGraphicsPipelines");
+m_vk.createComputePipelines = (CreateComputePipelinesFunc) GET_PROC_ADDR("vkCreateComputePipelines");
+m_vk.destroyPipeline = (DestroyPipelineFunc) GET_PROC_ADDR("vkDestroyPipeline");
+m_vk.createPipelineLayout = (CreatePipelineLayoutFunc) GET_PROC_ADDR("vkCreatePipelineLayout");
+m_vk.destroyPipelineLayout = (DestroyPipelineLayoutFunc) GET_PROC_ADDR("vkDestroyPipelineLayout");
+m_vk.createSampler = (CreateSamplerFunc) GET_PROC_ADDR("vkCreateSampler");
+m_vk.destroySampler = (DestroySamplerFunc) GET_PROC_ADDR("vkDestroySampler");
+m_vk.createDescriptorSetLayout = (CreateDescriptorSetLayoutFunc) GET_PROC_ADDR("vkCreateDescriptorSetLayout");
+m_vk.destroyDescriptorSetLayout = (DestroyDescriptorSetLayoutFunc) GET_PROC_ADDR("vkDestroyDescriptorSetLayout");
+m_vk.createDescriptorPool = (CreateDescriptorPoolFunc) GET_PROC_ADDR("vkCreateDescriptorPool");
+m_vk.destroyDescriptorPool = (DestroyDescriptorPoolFunc) GET_PROC_ADDR("vkDestroyDescriptorPool");
+m_vk.resetDescriptorPool = (ResetDescriptorPoolFunc) GET_PROC_ADDR("vkResetDescriptorPool");
+m_vk.allocDescriptorSets = (AllocDescriptorSetsFunc) GET_PROC_ADDR("vkAllocDescriptorSets");
+m_vk.updateDescriptorSets = (UpdateDescriptorSetsFunc) GET_PROC_ADDR("vkUpdateDescriptorSets");
+m_vk.createDynamicViewportState = (CreateDynamicViewportStateFunc) GET_PROC_ADDR("vkCreateDynamicViewportState");
+m_vk.destroyDynamicViewportState = (DestroyDynamicViewportStateFunc) GET_PROC_ADDR("vkDestroyDynamicViewportState");
+m_vk.createDynamicRasterState = (CreateDynamicRasterStateFunc) GET_PROC_ADDR("vkCreateDynamicRasterState");
+m_vk.destroyDynamicRasterState = (DestroyDynamicRasterStateFunc) GET_PROC_ADDR("vkDestroyDynamicRasterState");
+m_vk.createDynamicColorBlendState = (CreateDynamicColorBlendStateFunc) GET_PROC_ADDR("vkCreateDynamicColorBlendState");
+m_vk.destroyDynamicColorBlendState = (DestroyDynamicColorBlendStateFunc) GET_PROC_ADDR("vkDestroyDynamicColorBlendState");
+m_vk.createDynamicDepthStencilState = (CreateDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkCreateDynamicDepthStencilState");
+m_vk.destroyDynamicDepthStencilState = (DestroyDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkDestroyDynamicDepthStencilState");
+m_vk.createFramebuffer = (CreateFramebufferFunc) GET_PROC_ADDR("vkCreateFramebuffer");
+m_vk.destroyFramebuffer = (DestroyFramebufferFunc) GET_PROC_ADDR("vkDestroyFramebuffer");
+m_vk.createRenderPass = (CreateRenderPassFunc) GET_PROC_ADDR("vkCreateRenderPass");
+m_vk.destroyRenderPass = (DestroyRenderPassFunc) GET_PROC_ADDR("vkDestroyRenderPass");
+m_vk.getRenderAreaGranularity = (GetRenderAreaGranularityFunc) GET_PROC_ADDR("vkGetRenderAreaGranularity");
+m_vk.createCommandPool = (CreateCommandPoolFunc) GET_PROC_ADDR("vkCreateCommandPool");
+m_vk.destroyCommandPool = (DestroyCommandPoolFunc) GET_PROC_ADDR("vkDestroyCommandPool");
+m_vk.resetCommandPool = (ResetCommandPoolFunc) GET_PROC_ADDR("vkResetCommandPool");
+m_vk.createCommandBuffer = (CreateCommandBufferFunc) GET_PROC_ADDR("vkCreateCommandBuffer");
+m_vk.destroyCommandBuffer = (DestroyCommandBufferFunc) GET_PROC_ADDR("vkDestroyCommandBuffer");
+m_vk.beginCommandBuffer = (BeginCommandBufferFunc) GET_PROC_ADDR("vkBeginCommandBuffer");
+m_vk.endCommandBuffer = (EndCommandBufferFunc) GET_PROC_ADDR("vkEndCommandBuffer");
+m_vk.resetCommandBuffer = (ResetCommandBufferFunc) GET_PROC_ADDR("vkResetCommandBuffer");
+m_vk.cmdBindPipeline = (CmdBindPipelineFunc) GET_PROC_ADDR("vkCmdBindPipeline");
+m_vk.cmdBindDynamicViewportState = (CmdBindDynamicViewportStateFunc) GET_PROC_ADDR("vkCmdBindDynamicViewportState");
+m_vk.cmdBindDynamicRasterState = (CmdBindDynamicRasterStateFunc) GET_PROC_ADDR("vkCmdBindDynamicRasterState");
+m_vk.cmdBindDynamicColorBlendState = (CmdBindDynamicColorBlendStateFunc) GET_PROC_ADDR("vkCmdBindDynamicColorBlendState");
+m_vk.cmdBindDynamicDepthStencilState = (CmdBindDynamicDepthStencilStateFunc) GET_PROC_ADDR("vkCmdBindDynamicDepthStencilState");
+m_vk.cmdBindDescriptorSets = (CmdBindDescriptorSetsFunc) GET_PROC_ADDR("vkCmdBindDescriptorSets");
+m_vk.cmdBindIndexBuffer = (CmdBindIndexBufferFunc) GET_PROC_ADDR("vkCmdBindIndexBuffer");
+m_vk.cmdBindVertexBuffers = (CmdBindVertexBuffersFunc) GET_PROC_ADDR("vkCmdBindVertexBuffers");
+m_vk.cmdDraw = (CmdDrawFunc) GET_PROC_ADDR("vkCmdDraw");
+m_vk.cmdDrawIndexed = (CmdDrawIndexedFunc) GET_PROC_ADDR("vkCmdDrawIndexed");
+m_vk.cmdDrawIndirect = (CmdDrawIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndirect");
+m_vk.cmdDrawIndexedIndirect = (CmdDrawIndexedIndirectFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirect");
+m_vk.cmdDispatch = (CmdDispatchFunc) GET_PROC_ADDR("vkCmdDispatch");
+m_vk.cmdDispatchIndirect = (CmdDispatchIndirectFunc) GET_PROC_ADDR("vkCmdDispatchIndirect");
+m_vk.cmdCopyBuffer = (CmdCopyBufferFunc) GET_PROC_ADDR("vkCmdCopyBuffer");
+m_vk.cmdCopyImage = (CmdCopyImageFunc) GET_PROC_ADDR("vkCmdCopyImage");
+m_vk.cmdBlitImage = (CmdBlitImageFunc) GET_PROC_ADDR("vkCmdBlitImage");
+m_vk.cmdCopyBufferToImage = (CmdCopyBufferToImageFunc) GET_PROC_ADDR("vkCmdCopyBufferToImage");
+m_vk.cmdCopyImageToBuffer = (CmdCopyImageToBufferFunc) GET_PROC_ADDR("vkCmdCopyImageToBuffer");
+m_vk.cmdUpdateBuffer = (CmdUpdateBufferFunc) GET_PROC_ADDR("vkCmdUpdateBuffer");
+m_vk.cmdFillBuffer = (CmdFillBufferFunc) GET_PROC_ADDR("vkCmdFillBuffer");
+m_vk.cmdClearColorImage = (CmdClearColorImageFunc) GET_PROC_ADDR("vkCmdClearColorImage");
+m_vk.cmdClearDepthStencilImage = (CmdClearDepthStencilImageFunc) GET_PROC_ADDR("vkCmdClearDepthStencilImage");
+m_vk.cmdClearColorAttachment = (CmdClearColorAttachmentFunc) GET_PROC_ADDR("vkCmdClearColorAttachment");
+m_vk.cmdClearDepthStencilAttachment = (CmdClearDepthStencilAttachmentFunc) GET_PROC_ADDR("vkCmdClearDepthStencilAttachment");
+m_vk.cmdResolveImage = (CmdResolveImageFunc) GET_PROC_ADDR("vkCmdResolveImage");
+m_vk.cmdSetEvent = (CmdSetEventFunc) GET_PROC_ADDR("vkCmdSetEvent");
+m_vk.cmdResetEvent = (CmdResetEventFunc) GET_PROC_ADDR("vkCmdResetEvent");
+m_vk.cmdWaitEvents = (CmdWaitEventsFunc) GET_PROC_ADDR("vkCmdWaitEvents");
+m_vk.cmdPipelineBarrier = (CmdPipelineBarrierFunc) GET_PROC_ADDR("vkCmdPipelineBarrier");
+m_vk.cmdBeginQuery = (CmdBeginQueryFunc) GET_PROC_ADDR("vkCmdBeginQuery");
+m_vk.cmdEndQuery = (CmdEndQueryFunc) GET_PROC_ADDR("vkCmdEndQuery");
+m_vk.cmdResetQueryPool = (CmdResetQueryPoolFunc) GET_PROC_ADDR("vkCmdResetQueryPool");
+m_vk.cmdWriteTimestamp = (CmdWriteTimestampFunc) GET_PROC_ADDR("vkCmdWriteTimestamp");
+m_vk.cmdCopyQueryPoolResults = (CmdCopyQueryPoolResultsFunc) GET_PROC_ADDR("vkCmdCopyQueryPoolResults");
+m_vk.cmdPushConstants = (CmdPushConstantsFunc) GET_PROC_ADDR("vkCmdPushConstants");
+m_vk.cmdBeginRenderPass = (CmdBeginRenderPassFunc) GET_PROC_ADDR("vkCmdBeginRenderPass");
+m_vk.cmdNextSubpass = (CmdNextSubpassFunc) GET_PROC_ADDR("vkCmdNextSubpass");
+m_vk.cmdEndRenderPass = (CmdEndRenderPassFunc) GET_PROC_ADDR("vkCmdEndRenderPass");
+m_vk.cmdExecuteCommands = (CmdExecuteCommandsFunc) GET_PROC_ADDR("vkCmdExecuteCommands");
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+m_vk.destroyInstance = (DestroyInstanceFunc) GET_PROC_ADDR("vkDestroyInstance");
+m_vk.enumeratePhysicalDevices = (EnumeratePhysicalDevicesFunc) GET_PROC_ADDR("vkEnumeratePhysicalDevices");
+m_vk.getPhysicalDeviceFeatures = (GetPhysicalDeviceFeaturesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceFeatures");
+m_vk.getPhysicalDeviceFormatProperties = (GetPhysicalDeviceFormatPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceFormatProperties");
+m_vk.getPhysicalDeviceImageFormatProperties = (GetPhysicalDeviceImageFormatPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceImageFormatProperties");
+m_vk.getPhysicalDeviceLimits = (GetPhysicalDeviceLimitsFunc) GET_PROC_ADDR("vkGetPhysicalDeviceLimits");
+m_vk.getPhysicalDeviceProperties = (GetPhysicalDevicePropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceProperties");
+m_vk.getPhysicalDeviceQueueCount = (GetPhysicalDeviceQueueCountFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueCount");
+m_vk.getPhysicalDeviceQueueProperties = (GetPhysicalDeviceQueuePropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueProperties");
+m_vk.getPhysicalDeviceMemoryProperties = (GetPhysicalDeviceMemoryPropertiesFunc) GET_PROC_ADDR("vkGetPhysicalDeviceMemoryProperties");
+m_vk.getDeviceProcAddr = (GetDeviceProcAddrFunc) GET_PROC_ADDR("vkGetDeviceProcAddr");
+m_vk.createDevice = (CreateDeviceFunc) GET_PROC_ADDR("vkCreateDevice");
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-m_vk.createInstance = (CreateInstanceFunc) GET_PROC_ADDR("vkCreateInstance");
-m_vk.destroyInstance = (DestroyInstanceFunc) GET_PROC_ADDR("vkDestroyInstance");
-m_vk.enumeratePhysicalDevices = (EnumeratePhysicalDevicesFunc) GET_PROC_ADDR("vkEnumeratePhysicalDevices");
+m_vk.createInstance = (CreateInstanceFunc) GET_PROC_ADDR("vkCreateInstance");
+m_vk.getInstanceProcAddr = (GetInstanceProcAddrFunc) GET_PROC_ADDR("vkGetInstanceProcAddr");
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+
+VkResult InstanceDriver::destroyInstance (VkInstance instance) const
+{
+ return m_vk.destroyInstance(instance);
+}
+
+VkResult InstanceDriver::enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const
+{
+ return m_vk.enumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const
+{
+ return m_vk.getPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const
+{
+ return m_vk.getPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) const
+{
+ return m_vk.getPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) const
+{
+ return m_vk.getPhysicalDeviceLimits(physicalDevice, pLimits);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const
+{
+ return m_vk.getPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceQueueCount (VkPhysicalDevice physicalDevice, deUint32* pCount) const
+{
+ return m_vk.getPhysicalDeviceQueueCount(physicalDevice, pCount);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceQueueProperties (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties) const
+{
+ return m_vk.getPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const
+{
+ return m_vk.getPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+
+PFN_vkVoidFunction InstanceDriver::getDeviceProcAddr (VkDevice device, const char* pName) const
+{
+ return m_vk.getDeviceProcAddr(device, pName);
+}
+
+VkResult InstanceDriver::createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const
+{
+ return m_vk.createDevice(physicalDevice, pCreateInfo, pDevice);
+}
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+DestroyInstanceFunc destroyInstance;
+EnumeratePhysicalDevicesFunc enumeratePhysicalDevices;
+GetPhysicalDeviceFeaturesFunc getPhysicalDeviceFeatures;
+GetPhysicalDeviceFormatPropertiesFunc getPhysicalDeviceFormatProperties;
+GetPhysicalDeviceImageFormatPropertiesFunc getPhysicalDeviceImageFormatProperties;
+GetPhysicalDeviceLimitsFunc getPhysicalDeviceLimits;
+GetPhysicalDevicePropertiesFunc getPhysicalDeviceProperties;
+GetPhysicalDeviceQueueCountFunc getPhysicalDeviceQueueCount;
+GetPhysicalDeviceQueuePropertiesFunc getPhysicalDeviceQueueProperties;
+GetPhysicalDeviceMemoryPropertiesFunc getPhysicalDeviceMemoryProperties;
+GetDeviceProcAddrFunc getDeviceProcAddr;
+CreateDeviceFunc createDevice;
#include "vkMemUtil.hpp"
#include "vkStrUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkRef.hpp"
+#include "deInt32.h"
#include <sstream>
using de::MovePtr;
+namespace
+{
+
+deUint32 selectMemoryTypeWithProperties (const VkPhysicalDeviceMemoryProperties& deviceMemProps, deUint32 allowedMemTypeBits, VkMemoryPropertyFlags allocProps)
+{
+ for (deUint32 memoryTypeNdx = 0; memoryTypeNdx < deviceMemProps.memoryTypeCount; memoryTypeNdx++)
+ {
+ if ((allowedMemTypeBits & (1u << memoryTypeNdx)) != 0 &&
+ (deviceMemProps.memoryTypes[memoryTypeNdx].propertyFlags & allocProps) == allocProps)
+ return memoryTypeNdx;
+ }
+
+ TCU_THROW(NotSupportedError, "No compatible memory type found");
+}
+
+} // anonymous
+
// Allocation
Allocation::Allocation (VkDeviceMemory memory, VkDeviceSize offset)
class SimpleAllocation : public Allocation
{
public:
- SimpleAllocation (const DeviceInterface& vk, VkDevice device, VkDeviceMemory memory);
- virtual ~SimpleAllocation (void);
+ SimpleAllocation (Move<VkDeviceMemory> mem);
+ virtual ~SimpleAllocation (void);
private:
- const DeviceInterface& m_vk;
- const VkDevice m_device;
+ const Unique<VkDeviceMemory> m_memHolder;
};
-SimpleAllocation::SimpleAllocation (const DeviceInterface& vk, VkDevice device, VkDeviceMemory memory)
- : Allocation(memory, (VkDeviceSize)0)
- , m_vk (vk)
- , m_device (device)
+SimpleAllocation::SimpleAllocation (Move<VkDeviceMemory> mem)
+ : Allocation (*mem, (VkDeviceSize)0)
+ , m_memHolder (mem)
{
}
SimpleAllocation::~SimpleAllocation (void)
{
- m_vk.freeMemory(m_device, getMemory());
}
-SimpleAllocator::SimpleAllocator (const DeviceInterface& vk, VkDevice device)
+SimpleAllocator::SimpleAllocator (const DeviceInterface& vk, VkDevice device, const VkPhysicalDeviceMemoryProperties& deviceMemProps)
: m_vk (vk)
, m_device (device)
+ , m_memProps(deviceMemProps)
{
}
-MovePtr<Allocation> SimpleAllocator::allocate (const VkMemoryAllocInfo* allocInfo, VkDeviceSize alignment)
+MovePtr<Allocation> SimpleAllocator::allocate (const VkMemoryAllocInfo& allocInfo, VkDeviceSize alignment)
{
- VkDeviceMemory mem = DE_NULL;
-
- VK_CHECK(m_vk.allocMemory(m_device, allocInfo, &mem));
- TCU_CHECK(mem);
-
DE_UNREF(alignment);
-
- try
- {
- return MovePtr<Allocation>(new SimpleAllocation(m_vk, m_device, mem));
- }
- catch (...)
- {
- m_vk.freeMemory(m_device, mem);
- throw;
- }
+ return MovePtr<Allocation>(new SimpleAllocation(allocMemory(m_vk, m_device, &allocInfo)));
}
-// Utils
-
-MovePtr<Allocation> allocate (Allocator& allocator, VkDeviceSize allocationSize, VkMemoryPropertyFlags memProps, VkDeviceSize alignment, VkMemoryPriority memPriority)
+MovePtr<Allocation> SimpleAllocator::allocate (const VkMemoryRequirements& memReqs, VkMemoryPropertyFlags allocProps)
{
+ const deUint32 memoryTypeNdx = selectMemoryTypeWithProperties(m_memProps, memReqs.memoryTypeBits, allocProps);
const VkMemoryAllocInfo allocInfo =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- allocationSize, // VkDeviceSize allocationSize;
- memProps, // VkMemoryPropertyFlags memProps;
- memPriority, // VkMemoryPriority memPriority;
+ memReqs.size, // VkDeviceSize allocationSize;
+ memoryTypeNdx, // deUint32 memoryTypeIndex;
};
- return allocator.allocate(&allocInfo, alignment);
-}
-
-MovePtr<Allocation> allocate (Allocator& allocator, const VkMemoryRequirements& requirements, VkMemoryPropertyFlags memProps, VkMemoryPriority priority)
-{
- if ((requirements.memPropsAllowed & memProps) != memProps)
- {
- std::ostringstream msg;
- msg << getMemoryPropertyFlagsStr(memProps & ~requirements.memPropsAllowed) << " not supported by object type";
- TCU_THROW(NotSupportedError, msg.str().c_str());
- }
-
- return allocate(allocator, requirements.size, memProps | requirements.memPropsRequired, requirements.alignment, priority);
+ return allocate(allocInfo, memReqs.alignment);
}
} // vk
Allocator (void) {}
virtual ~Allocator (void) {}
- virtual de::MovePtr<Allocation> allocate (const VkMemoryAllocInfo* allocInfo, VkDeviceSize alignment) = 0;
+ virtual de::MovePtr<Allocation> allocate (const VkMemoryAllocInfo& allocInfo, VkDeviceSize alignment) = 0;
+ virtual de::MovePtr<Allocation> allocate (const VkMemoryRequirements& memRequirements, VkMemoryPropertyFlags allocProps) = 0;
};
//! Allocator that backs every allocation with its own VkDeviceMemory
class SimpleAllocator : public Allocator
{
public:
- SimpleAllocator (const DeviceInterface& vk, VkDevice device);
+ SimpleAllocator (const DeviceInterface& vk, VkDevice device, const VkPhysicalDeviceMemoryProperties& deviceMemProps);
- de::MovePtr<Allocation> allocate (const VkMemoryAllocInfo* allocInfo, VkDeviceSize alignment);
+ de::MovePtr<Allocation> allocate (const VkMemoryAllocInfo& allocInfo, VkDeviceSize alignment);
+ de::MovePtr<Allocation> allocate (const VkMemoryRequirements& memRequirements, VkMemoryPropertyFlags allocProps);
private:
- const DeviceInterface& m_vk;
- VkDevice m_device;
+ const DeviceInterface& m_vk;
+ const VkDevice m_device;
+ const VkPhysicalDeviceMemoryProperties m_memProps;
};
-// Utilities
-
-de::MovePtr<Allocation> allocate (Allocator& allocator,
- VkDeviceSize allocationSize,
- VkMemoryPropertyFlags memProps,
- VkDeviceSize alignment,
- VkMemoryPriority memPriority = VK_MEMORY_PRIORITY_UNUSED);
-
-de::MovePtr<Allocation> allocate (Allocator& allocator,
- const VkMemoryRequirements& requirements,
- VkMemoryPropertyFlags memProps = 0u,
- VkMemoryPriority priority = VK_MEMORY_PRIORITY_UNUSED);
-
} // vk
#endif // _VKMEMUTIL_HPP
*//*--------------------------------------------------------------------*/
#include "vkPlatform.hpp"
+#include "tcuFunctionLibrary.hpp"
namespace vk
{
-PlatformDriver::PlatformDriver (GetProcAddrFunc getProc)
+PlatformDriver::PlatformDriver (const tcu::FunctionLibrary& library)
{
- m_vk.getProcAddr = getProc;
-
-#define GET_PROC_ADDR(NAME) getProc(DE_NULL, NAME)
+#define GET_PROC_ADDR(NAME) library.getFunction(NAME)
#include "vkInitPlatformFunctionPointers.inl"
#undef GET_PROC_ADDR
}
{
}
-DeviceDriver::DeviceDriver (const PlatformInterface& platformInterface, VkPhysicalDevice device)
+InstanceDriver::InstanceDriver (const PlatformInterface& platformInterface, VkInstance instance)
+{
+#define GET_PROC_ADDR(NAME) platformInterface.getInstanceProcAddr(instance, NAME)
+#include "vkInitInstanceFunctionPointers.inl"
+#undef GET_PROC_ADDR
+}
+
+InstanceDriver::~InstanceDriver (void)
+{
+}
+
+DeviceDriver::DeviceDriver (const InstanceInterface& instanceInterface, VkDevice device)
{
-#define GET_PROC_ADDR(NAME) platformInterface.getProcAddr(device, NAME)
+#define GET_PROC_ADDR(NAME) instanceInterface.getDeviceProcAddr(device, NAME)
#include "vkInitDeviceFunctionPointers.inl"
#undef GET_PROC_ADDR
}
}
#include "vkPlatformDriverImpl.inl"
+#include "vkInstanceDriverImpl.inl"
#include "vkDeviceDriverImpl.inl"
} // vk
*//*--------------------------------------------------------------------*/
#include "vkDefs.hpp"
-#include "tcuFunctionLibrary.hpp"
+
+namespace tcu
+{
+class FunctionLibrary;
+}
namespace vk
{
virtual const PlatformInterface& getPlatformInterface (void) const = 0;
};
-DE_BEGIN_EXTERN_C
-
-#include "vkFunctionPointerTypes.inl"
-
-DE_END_EXTERN_C
-
class PlatformDriver : public PlatformInterface
{
public:
- PlatformDriver (GetProcAddrFunc getProc);
+ PlatformDriver (const tcu::FunctionLibrary& library);
~PlatformDriver (void);
#include "vkConcretePlatformInterface.inl"
Functions m_vk;
};
+class InstanceDriver : public InstanceInterface
+{
+public:
+ InstanceDriver (const PlatformInterface& platformInterface, VkInstance instance);
+ ~InstanceDriver (void);
+
+#include "vkConcreteInstanceInterface.inl"
+
+protected:
+ struct Functions
+ {
+#include "vkInstanceFunctionPointers.inl"
+ };
+
+ Functions m_vk;
+};
+
class DeviceDriver : public DeviceInterface
{
public:
- DeviceDriver (const PlatformInterface& platformInterface, VkPhysicalDevice device);
+ DeviceDriver (const InstanceInterface& instanceInterface, VkDevice device);
~DeviceDriver (void);
#include "vkConcreteDeviceInterface.inl"
return m_vk.createInstance(pCreateInfo, pInstance);
}
-VkResult PlatformDriver::destroyInstance (VkInstance instance) const
+PFN_vkVoidFunction PlatformDriver::getInstanceProcAddr (VkInstance instance, const char* pName) const
{
- return m_vk.destroyInstance(instance);
-}
-
-VkResult PlatformDriver::enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const
-{
- return m_vk.enumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-}
-
-FunctionPtr PlatformDriver::getProcAddr (VkPhysicalDevice physicalDevice, const char* pName) const
-{
- return m_vk.getProcAddr(physicalDevice, pName);
+ return m_vk.getInstanceProcAddr(instance, pName);
}
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-CreateInstanceFunc createInstance;
-DestroyInstanceFunc destroyInstance;
-EnumeratePhysicalDevicesFunc enumeratePhysicalDevices;
-GetProcAddrFunc getProcAddr;
+CreateInstanceFunc createInstance;
+GetInstanceProcAddrFunc getInstanceProcAddr;
// Utils
-namespace
-{
-
-// \todo [2015-05-12 pyry] All of this is just placeholder until we have proper SPIR-V binary support
-
-enum { GLSL_BINARY_MAGIC = 0x610d510a };
-
-struct BinaryHeader
-{
- deUint32 magic;
- deUint32 sourceLength[glu::SHADERTYPE_LAST]; // Length per stage, 0 means that not supplied
-};
-
-DE_STATIC_ASSERT(sizeof(BinaryHeader) == sizeof(deUint32)*7);
-
-size_t computeSrcArrayTotalLength (const vector<string>& sources)
-{
- size_t total = 0;
- for (vector<string>::const_iterator i = sources.begin(); i != sources.end(); ++i)
- total += i->length();
- return total;
-}
-
-size_t computeAggregatedSrcLength (const glu::ProgramSources& sources)
-{
- size_t total = 0;
- for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
- total += computeSrcArrayTotalLength(sources.sources[type]);
- return total;
-}
-
-void encodeGLSLBinary (const glu::ProgramSources& sources, vector<deUint8>& dst)
-{
- const size_t binarySize = sizeof(BinaryHeader) + computeAggregatedSrcLength(sources);
-
- dst.resize(binarySize);
-
- {
- BinaryHeader* const hdr = (BinaryHeader*)&dst[0];
- hdr->magic = GLSL_BINARY_MAGIC;
-
- for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
- hdr->sourceLength[type] = (deUint32)computeSrcArrayTotalLength(sources.sources[type]);
- }
-
- {
- size_t curOffset = sizeof(BinaryHeader);
- for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
- {
- for (vector<string>::const_iterator srcIter = sources.sources[type].begin();
- srcIter != sources.sources[type].end();
- ++srcIter)
- {
- if (!srcIter->empty())
- {
- deMemcpy(&dst[curOffset], srcIter->c_str(), (int)srcIter->length());
- curOffset += srcIter->length();
- }
- }
- }
- }
-}
-
-void decodeGLSLBinary (size_t binarySize, const deUint8* binary, glu::ProgramSources& dst)
-{
- const BinaryHeader* hdr = (const BinaryHeader*)binary;
-
- if (binarySize < sizeof(BinaryHeader) || hdr->magic != GLSL_BINARY_MAGIC)
- TCU_THROW(Exception, "Invalid GLSL program binary");
-
- {
- size_t curOffset = sizeof(BinaryHeader);
-
- for (int type = 0; type < glu::SHADERTYPE_LAST; type++)
- {
- if (hdr->sourceLength[type] > 0)
- {
- if (curOffset+hdr->sourceLength[type] > binarySize)
- TCU_THROW(Exception, "Incomplete GLSL program binary");
-
- dst.sources[type].resize(1);
- dst.sources[type][0] = std::string((const char*)&binary[curOffset], hdr->sourceLength[type]);
-
- curOffset += hdr->sourceLength[type];
- }
- else
- dst.sources[type].clear();
- }
- }
-}
-
-VkShaderStage getShaderStage (glu::ShaderType type)
-{
- static const VkShaderStage stageMap[] =
- {
- VK_SHADER_STAGE_VERTEX,
- VK_SHADER_STAGE_FRAGMENT,
- VK_SHADER_STAGE_GEOMETRY,
- VK_SHADER_STAGE_TESS_CONTROL,
- VK_SHADER_STAGE_TESS_EVALUATION,
- VK_SHADER_STAGE_COMPUTE,
- };
- return de::getSizedArrayElement<glu::SHADERTYPE_LAST>(stageMap, type);
-}
-
-} // anonymous
-
ProgramBinary* buildProgram (const glu::ProgramSources& program, ProgramFormat binaryFormat)
{
- if (binaryFormat == PROGRAM_FORMAT_GLSL_SOURCE)
- {
- vector<deUint8> binary;
- encodeGLSLBinary(program, binary);
- return new ProgramBinary(binaryFormat, binary.size(), &binary[0]);
- }
- else if (binaryFormat == PROGRAM_FORMAT_SPIRV)
+ if (binaryFormat == PROGRAM_FORMAT_SPIRV)
{
vector<deUint8> binary;
glslToSpirV(program, binary);
TCU_THROW(NotSupportedError, "Unsupported program format");
}
-Move<VkShaderT> createShader (const DeviceInterface& deviceInterface, VkDevice device, const ProgramBinary& binary, VkShaderCreateFlags flags)
+Move<VkShaderModule> createShaderModule (const DeviceInterface& deviceInterface, VkDevice device, const ProgramBinary& binary, VkShaderModuleCreateFlags flags)
{
- if (binary.getFormat() == PROGRAM_FORMAT_GLSL_SOURCE)
- {
- // HACK: just concatenate everything
- glu::ProgramSources sources;
- std::string concatenated;
-
- decodeGLSLBinary(binary.getSize(), binary.getBinary(), sources);
-
- for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
- {
- for (size_t ndx = 0; ndx < sources.sources[shaderType].size(); ++ndx)
- concatenated += sources.sources[shaderType][ndx];
- }
-
- {
- const struct VkShaderCreateInfo shaderInfo =
- {
- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (deUintptr)concatenated.size(), // deUintptr codeSize;
- concatenated.c_str(), // const void* pCode;
- flags, // VkShaderCreateFlags flags;
- };
-
- return createShader(deviceInterface, device, &shaderInfo);
- }
- }
- else if (binary.getFormat() == PROGRAM_FORMAT_SPIRV)
+ if (binary.getFormat() == PROGRAM_FORMAT_SPIRV)
{
- const struct VkShaderCreateInfo shaderInfo =
+ const struct VkShaderModuleCreateInfo shaderModuleInfo =
{
- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (deUintptr)binary.getSize(), // deUintptr codeSize;
- binary.getBinary(), // const void* pCode;
- flags, // VkShaderCreateFlags flags;
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (deUintptr)binary.getSize(), // deUintptr codeSize;
+ binary.getBinary(), // const void* pCode;
+ flags, // VkShaderModuleCreateFlags flags;
};
- return createShader(deviceInterface, device, &shaderInfo);
+ return createShaderModule(deviceInterface, device, &shaderModuleInfo);
}
else
TCU_THROW(NotSupportedError, "Unsupported program format");
enum ProgramFormat
{
- PROGRAM_FORMAT_GLSL_SOURCE = 0,
- PROGRAM_FORMAT_SPIRV,
+ PROGRAM_FORMAT_SPIRV = 0,
PROGRAM_FORMAT_LAST
};
typedef ProgramCollection<ProgramBinary> BinaryCollection;
// \todo [2015-03-13 pyry] Likely need BinaryBuilder abstraction for this
-ProgramBinary* buildProgram (const glu::ProgramSources& program, ProgramFormat binaryFormat);
-Move<VkShaderT> createShader (const DeviceInterface& deviceInterface, VkDevice device, const ProgramBinary& binary, VkShaderCreateFlags flags);
+ProgramBinary* buildProgram (const glu::ProgramSources& program, ProgramFormat binaryFormat);
+Move<VkShaderModule> createShaderModule (const DeviceInterface& deviceInterface, VkDevice device, const ProgramBinary& binary, VkShaderModuleCreateFlags flags);
} // vk
namespace vk
{
-std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const PlatformInterface& vk, VkInstance instance)
+std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance)
{
deUint32 numDevices = 0;
std::vector<VkPhysicalDevice> devices;
return devices;
}
+
+std::vector<VkPhysicalDeviceQueueProperties> getPhysicalDeviceQueueProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
+{
+ deUint32 numQueues = 0;
+ std::vector<VkPhysicalDeviceQueueProperties> properties;
+
+ VK_CHECK(vk.getPhysicalDeviceQueueCount(physicalDevice, &numQueues));
+
+ if (numQueues > 0)
+ {
+ properties.resize(numQueues);
+ VK_CHECK(vk.getPhysicalDeviceQueueProperties(physicalDevice, numQueues, &properties[0]));
+ }
+
+ return properties;
+}
+
+VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
+{
+ VkPhysicalDeviceMemoryProperties properties;
+ VK_CHECK(vk.getPhysicalDeviceMemoryProperties(physicalDevice, &properties));
+ return properties;
+}
+
+VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer)
+{
+ VkMemoryRequirements req;
+ VK_CHECK(vk.getBufferMemoryRequirements(device, buffer, &req));
+ return req;
+}
+VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image)
+{
+ VkMemoryRequirements req;
+ VK_CHECK(vk.getImageMemoryRequirements(device, image, &req));
+ return req;
+}
+
} // vk
*//*--------------------------------------------------------------------*/
#include "vkDefs.hpp"
-#include "vkRef.hpp"
-#include "deMeta.hpp"
#include <vector>
namespace vk
{
-namespace querydetails
-{
-
-enum QueryResultCount
-{
- QUERY_RESULT_COUNT_SINGLE = 0,
- QUERY_RESULT_COUNT_MULTIPLE = 1
-};
-
-template<VkPhysicalDeviceInfoType InfoType>
-struct PhysicalDeviceInfoTraits;
-
-#define VK_DECLARE_QUERY_TRAITS(QUERY_CLASS, QUERY_PARAM, RESULT_TYPE, RESULT_COUNT) \
-template<> \
-struct QUERY_CLASS##Traits<QUERY_PARAM> \
-{ \
- typedef RESULT_TYPE Type; \
- enum { QUERY_RESULT_COUNT = QUERY_RESULT_COUNT_##RESULT_COUNT }; \
-}
-
-VK_DECLARE_QUERY_TRAITS(PhysicalDeviceInfo, VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES, VkPhysicalDeviceProperties, SINGLE);
-VK_DECLARE_QUERY_TRAITS(PhysicalDeviceInfo, VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE, VkPhysicalDevicePerformance, SINGLE);
-VK_DECLARE_QUERY_TRAITS(PhysicalDeviceInfo, VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES, VkPhysicalDeviceQueueProperties, MULTIPLE);
-VK_DECLARE_QUERY_TRAITS(PhysicalDeviceInfo, VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES, VkPhysicalDeviceMemoryProperties, MULTIPLE);
-
-template<VkPhysicalDeviceInfoType InfoType>
-std::vector<typename PhysicalDeviceInfoTraits<InfoType>::Type> getPhysicalDeviceInfoImpl (const DeviceInterface& vk, VkPhysicalDevice physicalDevice)
-{
- std::vector<typename PhysicalDeviceInfoTraits<InfoType>::Type> values;
- deUintptr infoSize = 0;
-
- VK_CHECK(vk.getPhysicalDeviceInfo(physicalDevice, InfoType, &infoSize, DE_NULL));
-
- if (infoSize % sizeof(typename PhysicalDeviceInfoTraits<InfoType>::Type) != 0)
- TCU_FAIL("Returned info size is not divisible by structure size");
-
- if (infoSize > 0)
- {
- values.resize(infoSize / sizeof(typename PhysicalDeviceInfoTraits<InfoType>::Type));
- VK_CHECK(vk.getPhysicalDeviceInfo(physicalDevice, InfoType, &infoSize, &values[0]));
-
- if (infoSize != values.size()*sizeof(typename PhysicalDeviceInfoTraits<InfoType>::Type))
- TCU_FAIL("Returned info size changed between queries");
- }
-
- return values;
-}
-
-template<VkPhysicalDeviceInfoType InfoType>
-std::vector<typename PhysicalDeviceInfoTraits<InfoType>::Type> getPhysicalDeviceInfo (typename de::meta::EnableIf<const DeviceInterface&, PhysicalDeviceInfoTraits<InfoType>::QUERY_RESULT_COUNT == QUERY_RESULT_COUNT_MULTIPLE>::Type vk, VkPhysicalDevice physicalDevice)
-{
- return getPhysicalDeviceInfoImpl<InfoType>(vk, physicalDevice);
-}
-
-template<VkPhysicalDeviceInfoType InfoType>
-typename PhysicalDeviceInfoTraits<InfoType>::Type getPhysicalDeviceInfo (typename de::meta::EnableIf<const DeviceInterface&, PhysicalDeviceInfoTraits<InfoType>::QUERY_RESULT_COUNT == QUERY_RESULT_COUNT_SINGLE>::Type vk, VkPhysicalDevice physicalDevice)
-{
- const std::vector<typename PhysicalDeviceInfoTraits<InfoType>::Type> values = getPhysicalDeviceInfoImpl<InfoType>(vk, physicalDevice);
-
- if (values.size() != 1)
- TCU_FAIL("Expected only single value");
-
- return values[0];
-}
-
-template<VkObjectInfoType InfoType>
-struct ObjectInfoTraits;
-
-VK_DECLARE_QUERY_TRAITS(ObjectInfo, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, VkMemoryRequirements, MULTIPLE);
-
-template<VkObjectInfoType InfoType>
-std::vector<typename ObjectInfoTraits<InfoType>::Type> getObjectInfoImpl (const DeviceInterface& vk, VkDevice device, VkObjectType objectType, VkObject object)
-{
- std::vector<typename ObjectInfoTraits<InfoType>::Type> values;
- deUintptr infoSize = 0;
-
- VK_CHECK(vk.getObjectInfo(device, objectType, object, InfoType, &infoSize, DE_NULL));
-
- if (infoSize % sizeof(typename ObjectInfoTraits<InfoType>::Type) != 0)
- TCU_FAIL("Returned info size is not divisible by structure size");
-
- if (infoSize > 0)
- {
- values.resize(infoSize / sizeof(typename ObjectInfoTraits<InfoType>::Type));
- VK_CHECK(vk.getObjectInfo(device, objectType, object, InfoType, &infoSize, &values[0]));
-
- if (infoSize != values.size()*sizeof(typename ObjectInfoTraits<InfoType>::Type))
- TCU_FAIL("Returned info size changed between queries");
- }
-
- return values;
-}
-
-template<VkObjectInfoType InfoType>
-std::vector<typename ObjectInfoTraits<InfoType>::Type> getObjectInfo (typename de::meta::EnableIf<const DeviceInterface&, ObjectInfoTraits<InfoType>::QUERY_RESULT_COUNT == QUERY_RESULT_COUNT_MULTIPLE>::Type vk, VkDevice device, VkObjectType objectType, VkObject object)
-{
- return getObjectInfoImpl<InfoType>(vk, device, objectType, object);
-}
-
-template<VkObjectInfoType InfoType, typename T>
-std::vector<typename ObjectInfoTraits<InfoType>::Type> getObjectInfo (typename de::meta::EnableIf<const DeviceInterface&, ObjectInfoTraits<InfoType>::QUERY_RESULT_COUNT == QUERY_RESULT_COUNT_MULTIPLE>::Type vk, VkDevice device, const Unique<T>& object)
-{
- return getObjectInfo<InfoType>(vk, device, getObjectType<T>(), object.get());
-}
-
-} // querydetails
-using querydetails::getPhysicalDeviceInfo;
-using querydetails::getObjectInfo;
+std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance);
+std::vector<VkPhysicalDeviceQueueProperties> getPhysicalDeviceQueueProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
+VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
-std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const PlatformInterface& vk, VkInstance instance);
+VkMemoryRequirements getBufferMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkBuffer buffer);
+VkMemoryRequirements getImageMemoryRequirements (const DeviceInterface& vk, VkDevice device, VkImage image);
} // vk
#include "vkRefUtilImpl.inl"
+Move<VkPipeline> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo)
+{
+ VkPipeline object = 0;
+ VK_CHECK(vk.createGraphicsPipelines(device, pipelineCache, 1u, pCreateInfo, &object));
+ return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device));
+}
+
+Move<VkPipeline> createComputePipeline (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkComputePipelineCreateInfo* pCreateInfo)
+{
+ VkPipeline object = 0;
+ VK_CHECK(vk.createComputePipelines(device, pipelineCache, 1u, pCreateInfo, &object));
+ return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device));
+}
+
} // vk
#include "vkDefs.hpp"
#include "vkStrUtil.hpp"
+#include "deUniquePtr.hpp"
#include "deMeta.hpp"
+#include <algorithm>
+
namespace vk
{
namespace refdetails
{
-using de::meta::EnableIf;
-
-template<typename T>
-struct RefTraits
-{
- typedef DeviceInterface Interface;
- enum { REQUIRES_DEVICE = 1 };
-};
-
-template<>
-struct RefTraits<VkInstanceT>
-{
- typedef PlatformInterface Interface;
- enum { REQUIRES_DEVICE = 0 };
-};
-
-template<>
-struct RefTraits<VkDeviceT>
-{
- typedef DeviceInterface Interface;
- enum { REQUIRES_DEVICE = 0 };
-};
+using std::swap;
template<typename T>
struct Checked
{
- explicit inline Checked (typename Traits<T>::Type object_) : object(object_) {}
+ explicit inline Checked (T object_) : object(object_) {}
- typename Traits<T>::Type object;
+ T object;
};
//! Check that object is not null
template<typename T>
-inline Checked<T> check (typename Traits<T>::Type object)
+inline Checked<T> check (T object)
{
if (!object)
throw tcu::TestError("Object check() failed", (std::string(getTypeName<T>()) + " = 0").c_str(), __FILE__, __LINE__);
//! Declare object as checked earlier
template<typename T>
-inline Checked<T> notNull (typename Traits<T>::Type object)
+inline Checked<T> notNull (T object)
{
if (!object)
throw tcu::InternalError("Null object was given to notNull()", (std::string(getTypeName<T>()) + " = 0").c_str(), __FILE__, __LINE__);
//! Allow null object
template<typename T>
-inline Checked<T> allowNull (typename Traits<T>::Type object)
+inline Checked<T> allowNull (T object)
{
return Checked<T>(object);
}
-// \todo [2015-05-12 pyry] Can we further simplify this using RefTraits<T>::REQUIRES_DEVICE?
-
template<typename T>
-struct RefData
+class Deleter
{
- RefData (const typename RefTraits<T>::Interface* vk_,
- VkDevice device_,
- typename Traits<T>::Type object_)
- : vk (vk_)
- , device(device_)
- , object(object_)
- {}
- RefData (const typename RefTraits<T>::Interface* vk_)
- : vk (vk_)
- , device(0)
- , object(0)
- {}
-
- const typename RefTraits<T>::Interface* vk;
- VkDevice device;
- typename Traits<T>::Type object;
-};
+public:
+ Deleter (const DeviceInterface& deviceIface, VkDevice device)
+ : m_deviceIface (&deviceIface)
+ , m_device (device)
+ {}
+ Deleter (void)
+ : m_deviceIface (DE_NULL)
+ , m_device (DE_NULL)
+ {}
-template<>
-struct RefData<VkInstanceT>
-{
- RefData (const RefTraits<VkInstanceT>::Interface* vk_,
- VkInstance object_)
- : vk (vk_)
- , object (object_)
- {}
- RefData (const RefTraits<VkInstanceT>::Interface* vk_)
- : vk (vk_)
- , object(0)
- {}
-
- const RefTraits<VkInstanceT>::Interface* vk;
- Traits<VkInstanceT>::Type object;
-};
+ void operator() (T obj) const;
-template<>
-struct RefData<VkDeviceT>
-{
- RefData (const RefTraits<VkDeviceT>::Interface* vk_,
- VkDevice object_)
- : vk (vk_)
- , object (object_)
- {}
- RefData (const RefTraits<VkDevice>::Interface* vk_)
- : vk (vk_)
- , object(0)
- {}
-
- const RefTraits<VkDeviceT>::Interface* vk;
- Traits<VkDeviceT>::Type object;
+private:
+ const DeviceInterface* m_deviceIface;
+ VkDevice m_device;
};
-template<typename T>
-bool hasObject (const RefData<T>& ref)
-{
- return ref.object != 0;
-}
-
-template<typename T>
-void clearObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 1>::Type& ref)
-{
- ref.object = 0;
- ref.device = 0;
-}
-
-template<typename T>
-void clearObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 0>::Type& ref)
-{
- ref.object = 0;
-}
-
-template<typename T>
-void assignObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 1>::Type& dst, const RefData<T>& src)
-{
- dst.object = src.object;
- dst.device = src.device;
-}
-
-template<typename T>
-void assignObject (typename EnableIf<RefData<T>, RefTraits<T>::REQUIRES_DEVICE == 0>::Type& dst, const RefData<T>& src)
-{
- dst.object = src.object;
-}
-
-template<typename T>
-void destroyObject (const RefData<T>& ref)
-{
- ref.vk->destroyObject(ref.device, getObjectType<T>(), ref.object);
-}
-
template<>
-inline void destroyObject<VkInstanceT> (const RefData<VkInstanceT>& ref)
+class Deleter<VkInstance>
{
- ref.vk->destroyInstance(ref.object);
-}
+public:
+ Deleter (const PlatformInterface& platformIface, VkInstance instance)
+ : m_destroyInstance((DestroyInstanceFunc)platformIface.getInstanceProcAddr(instance, "vkDestroyInstance"))
+ {}
+ Deleter (void)
+ : m_destroyInstance((DestroyInstanceFunc)DE_NULL)
+ {}
-template<>
-inline void destroyObject<VkDeviceT> (const RefData<VkDeviceT>& ref)
-{
- ref.vk->destroyDevice(ref.object);
-}
+ void operator() (VkInstance obj) const { DE_TEST_ASSERT(m_destroyInstance(obj) == VK_SUCCESS); }
-template<>
-inline void destroyObject<VkDeviceMemoryT> (const RefData<VkDeviceMemoryT>& ref)
-{
- ref.vk->freeMemory(ref.device, ref.object);
-}
+private:
+ DestroyInstanceFunc m_destroyInstance;
+};
-template<typename T>
-class RefBase
+template<>
+class Deleter<VkDevice>
{
public:
- ~RefBase (void);
-
- inline const typename Traits<T>::Type& get (void) const throw() { return m_data.object; }
- inline const typename Traits<T>::Type& operator* (void) const throw() { return get(); }
- inline operator bool (void) const throw() { return !!get(); }
-protected:
- RefBase (RefData<T> data) : m_data(data) {}
+ Deleter (const InstanceInterface& instanceIface, VkDevice device)
+ : m_destroyDevice((DestroyDeviceFunc)instanceIface.getDeviceProcAddr(device, "vkDestroyDevice"))
+ {}
+ Deleter (void)
+ : m_destroyDevice((DestroyDeviceFunc)DE_NULL)
+ {}
- void reset (void); //!< Release previous object, set to null.
- RefData<T> disown (void) throw(); //!< Disown and return object (ownership transferred to caller).
- void assign (RefData<T> data); //!< Set new pointer, release previous pointer.
+ void operator() (VkDevice obj) const { DE_TEST_ASSERT(m_destroyDevice(obj) == VK_SUCCESS); }
private:
- RefData<T> m_data;
+ DestroyDeviceFunc m_destroyDevice;
};
-/*--------------------------------------------------------------------*//*!
- * \brief Movable Vulkan object reference.
- *
- * Similar to de::MovePtr.
- *//*--------------------------------------------------------------------*/
template<typename T>
-class Move : public RefBase<T>
+struct RefData
{
-public:
- template<typename U>
- Move (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==1>::Type vk,
- VkDevice device,
- Checked<U> object)
- : RefBase<T>(RefData<T>(&vk, device, object.object))
+ RefData (T object_, Deleter<T> deleter_)
+ : object (object_)
+ , deleter (deleter_)
{}
-
- template<typename U>
- Move (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==0>::Type vk,
- Checked<U> object)
- : RefBase<T>(RefData<T>(&vk, object.object))
+ RefData (void)
+ : object (0)
{}
- Move (const typename RefTraits<T>::Interface& vk) : RefBase<T>(RefData<T>(&vk)) {}
- Move (RefData<T> data) : RefBase<T>(data) {}
-
- Move<T>& operator= (Move<T>& other);
- Move<T>& operator= (RefData<T> data);
-
- operator RefData<T> (void) { return this->disown(); }
+ T object;
+ Deleter<T> deleter;
};
-/*--------------------------------------------------------------------*//*!
- * \brief Unique Vulkan object reference.
- *
- * Similar to de::UniquePtr.
- *//*--------------------------------------------------------------------*/
template<typename T>
-class Unique : public RefBase<T>
+class RefBase
{
public:
- template<typename U>
- Unique (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==1>::Type vk,
- VkDevice device,
- Checked<U> object)
- : RefBase<T>(RefData<T>(&vk, device, object.object))
- {}
+ ~RefBase (void);
- template<typename U>
- Unique (typename EnableIf<const typename RefTraits<U>::Interface&, RefTraits<U>::REQUIRES_DEVICE==0>::Type vk,
- Checked<U> object)
- : RefBase<T>(RefData<T>(&vk, object.object))
- {}
+ inline const T& get (void) const throw() { return m_data.object; }
+ inline const T& operator* (void) const throw() { return get(); }
+ inline operator bool (void) const throw() { return !!get(); }
- Unique (RefData<T> data) : RefBase<T>(data) {}
-};
+protected:
+ RefBase (RefData<T> data) : m_data(data) {}
+
+ void reset (void); //!< Release previous object, set to null.
+ RefData<T> disown (void) throw(); //!< Disown and return object (ownership transferred to caller).
+ void assign (RefData<T> data); //!< Set new pointer, release previous pointer.
-// RefBase
+private:
+ RefData<T> m_data;
+};
template<typename T>
inline RefBase<T>::~RefBase (void)
template<typename T>
inline void RefBase<T>::reset (void)
{
- if (hasObject(m_data))
- destroyObject<T>(m_data);
+ if (!!m_data.object)
+ m_data.deleter(m_data.object);
- clearObject<T>(m_data);
+ m_data = RefData<T>();
}
template<typename T>
inline RefData<T> RefBase<T>::disown (void) throw()
{
- const RefData<T> old = m_data;
- clearObject<T>(m_data);
- return old;
+ RefData<T> tmp;
+ swap(m_data, tmp);
+ return tmp;
}
template<typename T>
inline void RefBase<T>::assign (RefData<T> data)
{
this->reset();
- assignObject<T>(m_data, data);
+ m_data = data;
}
-// Move
+/*--------------------------------------------------------------------*//*!
+ * \brief Movable Vulkan object reference.
+ *
+ * Similar to de::MovePtr.
+ *//*--------------------------------------------------------------------*/
+template<typename T>
+class Move : public RefBase<T>
+{
+public:
+ template<typename U>
+ Move (Checked<U> object, Deleter<U> deleter)
+ : RefBase<T>(RefData<T>(object.object, deleter))
+ {}
+
+ Move (RefData<T> data)
+ : RefBase<T>(data)
+ {}
+ Move (void)
+ : RefBase<T>(RefData<T>())
+ {}
+
+ Move<T>& operator= (Move<T>& other);
+ Move<T>& operator= (RefData<T> data);
+
+ operator RefData<T> (void) { return this->disown(); }
+};
template<typename T>
inline Move<T>& Move<T>::operator= (Move<T>& other)
return *this;
}
+/*--------------------------------------------------------------------*//*!
+ * \brief Unique Vulkan object reference.
+ *
+ * Similar to de::UniquePtr.
+ *//*--------------------------------------------------------------------*/
+template<typename T>
+class Unique : public RefBase<T>
+{
+public:
+ template<typename U>
+ Unique (Checked<U> object, Deleter<U> deleter)
+ : RefBase<T>(RefData<T>(object.object, deleter))
+ {}
+
+ Unique (RefData<T> data)
+ : RefBase<T>(data)
+ {}
+};
+
} // refdetails
using refdetails::Move;
using refdetails::Unique;
+using refdetails::Deleter;
using refdetails::check;
using refdetails::notNull;
using refdetails::allowNull;
#include "vkRefUtil.inl"
+Move<VkPipeline> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo);
+Move<VkPipeline> createComputePipeline (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkComputePipelineCreateInfo* pCreateInfo);
+
} // vk
#endif // _VKREF_HPP
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-Move<VkInstanceT> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo);
-Move<VkDeviceT> createDevice (const DeviceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo);
-Move<VkDeviceMemoryT> allocMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocInfo* pAllocInfo);
-Move<VkFenceT> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo);
-Move<VkSemaphoreT> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo);
-Move<VkEventT> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo);
-Move<VkQueryPoolT> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo);
-Move<VkBufferT> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo);
-Move<VkBufferViewT> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo);
-Move<VkImageT> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo);
-Move<VkImageViewT> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo);
-Move<VkColorAttachmentViewT> createColorAttachmentView (const DeviceInterface& vk, VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo);
-Move<VkDepthStencilViewT> createDepthStencilView (const DeviceInterface& vk, VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo);
-Move<VkShaderT> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo);
-Move<VkPipelineT> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo);
-Move<VkPipelineT> createGraphicsPipelineDerivative (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline);
-Move<VkPipelineT> createComputePipeline (const DeviceInterface& vk, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo);
-Move<VkPipelineLayoutT> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo);
-Move<VkSamplerT> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo);
-Move<VkDescriptorSetLayoutT> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
-Move<VkDescriptorPoolT> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo);
-Move<VkDynamicVpStateT> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo);
-Move<VkDynamicRsStateT> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo);
-Move<VkDynamicCbStateT> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo);
-Move<VkDynamicDsStateT> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo);
-Move<VkCmdBufferT> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo);
-Move<VkFramebufferT> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo);
-Move<VkRenderPassT> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo);
+Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo);
+Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo);
+Move<VkDeviceMemory> allocMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocInfo* pAllocInfo);
+Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo);
+Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo);
+Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo);
+Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo);
+Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo);
+Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo);
+Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo);
+Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo);
+Move<VkAttachmentView> createAttachmentView (const DeviceInterface& vk, VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo);
+Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo);
+Move<VkShader> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo);
+Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo);
+Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo);
+Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo);
+Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo);
+Move<VkDynamicViewportState> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo);
+Move<VkDynamicRasterState> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo);
+Move<VkDynamicColorBlendState> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo);
+Move<VkDynamicDepthStencilState> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo);
+Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo);
+Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo);
+Move<VkCmdPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo);
+Move<VkCmdBuffer> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo);
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-Move<VkInstanceT> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo)
+namespace refdetails
+{
+
+template<>
+void Deleter<VkDeviceMemory>::operator() (VkDeviceMemory obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->freeMemory(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkFence>::operator() (VkFence obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyFence(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkSemaphore>::operator() (VkSemaphore obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroySemaphore(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkEvent>::operator() (VkEvent obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyEvent(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkQueryPool>::operator() (VkQueryPool obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyQueryPool(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkBuffer>::operator() (VkBuffer obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyBuffer(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkBufferView>::operator() (VkBufferView obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyBufferView(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkImage>::operator() (VkImage obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyImage(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkImageView>::operator() (VkImageView obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyImageView(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkAttachmentView>::operator() (VkAttachmentView obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyAttachmentView(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkShaderModule>::operator() (VkShaderModule obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyShaderModule(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkShader>::operator() (VkShader obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyShader(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkPipelineCache>::operator() (VkPipelineCache obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyPipelineCache(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkPipeline>::operator() (VkPipeline obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyPipeline(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkPipelineLayout>::operator() (VkPipelineLayout obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyPipelineLayout(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkSampler>::operator() (VkSampler obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroySampler(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkDescriptorSetLayout>::operator() (VkDescriptorSetLayout obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyDescriptorSetLayout(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkDescriptorPool>::operator() (VkDescriptorPool obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyDescriptorPool(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkDynamicViewportState>::operator() (VkDynamicViewportState obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyDynamicViewportState(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkDynamicRasterState>::operator() (VkDynamicRasterState obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyDynamicRasterState(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkDynamicColorBlendState>::operator() (VkDynamicColorBlendState obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyDynamicColorBlendState(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkDynamicDepthStencilState>::operator() (VkDynamicDepthStencilState obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyDynamicDepthStencilState(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkFramebuffer>::operator() (VkFramebuffer obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyFramebuffer(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkRenderPass>::operator() (VkRenderPass obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyRenderPass(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkCmdPool>::operator() (VkCmdPool obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyCommandPool(m_device, obj) == VK_SUCCESS);
+}
+
+template<>
+void Deleter<VkCmdBuffer>::operator() (VkCmdBuffer obj) const
+{
+ DE_TEST_ASSERT(m_deviceIface->destroyCommandBuffer(m_device, obj) == VK_SUCCESS);
+}
+
+} // refdetails
+
+Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo)
{
VkInstance object = 0;
VK_CHECK(vk.createInstance(pCreateInfo, &object));
- return Move<VkInstanceT>(vk, check<VkInstanceT>(object));
+ return Move<VkInstance>(check<VkInstance>(object), Deleter<VkInstance>(vk, object));
}
-Move<VkDeviceT> createDevice (const DeviceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo)
+Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo)
{
VkDevice object = 0;
VK_CHECK(vk.createDevice(physicalDevice, pCreateInfo, &object));
- return Move<VkDeviceT>(vk, check<VkDeviceT>(object));
+ return Move<VkDevice>(check<VkDevice>(object), Deleter<VkDevice>(vk, object));
}
-Move<VkDeviceMemoryT> allocMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocInfo* pAllocInfo)
+Move<VkDeviceMemory> allocMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocInfo* pAllocInfo)
{
VkDeviceMemory object = 0;
VK_CHECK(vk.allocMemory(device, pAllocInfo, &object));
- return Move<VkDeviceMemoryT>(vk, device, check<VkDeviceMemoryT>(object));
+ return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device));
}
-Move<VkFenceT> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo)
+Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo)
{
VkFence object = 0;
VK_CHECK(vk.createFence(device, pCreateInfo, &object));
- return Move<VkFenceT>(vk, device, check<VkFenceT>(object));
+ return Move<VkFence>(check<VkFence>(object), Deleter<VkFence>(vk, device));
}
-Move<VkSemaphoreT> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo)
+Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo)
{
VkSemaphore object = 0;
VK_CHECK(vk.createSemaphore(device, pCreateInfo, &object));
- return Move<VkSemaphoreT>(vk, device, check<VkSemaphoreT>(object));
+ return Move<VkSemaphore>(check<VkSemaphore>(object), Deleter<VkSemaphore>(vk, device));
}
-Move<VkEventT> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo)
+Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo)
{
VkEvent object = 0;
VK_CHECK(vk.createEvent(device, pCreateInfo, &object));
- return Move<VkEventT>(vk, device, check<VkEventT>(object));
+ return Move<VkEvent>(check<VkEvent>(object), Deleter<VkEvent>(vk, device));
}
-Move<VkQueryPoolT> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo)
+Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo)
{
VkQueryPool object = 0;
VK_CHECK(vk.createQueryPool(device, pCreateInfo, &object));
- return Move<VkQueryPoolT>(vk, device, check<VkQueryPoolT>(object));
+ return Move<VkQueryPool>(check<VkQueryPool>(object), Deleter<VkQueryPool>(vk, device));
}
-Move<VkBufferT> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo)
+Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo)
{
VkBuffer object = 0;
VK_CHECK(vk.createBuffer(device, pCreateInfo, &object));
- return Move<VkBufferT>(vk, device, check<VkBufferT>(object));
+ return Move<VkBuffer>(check<VkBuffer>(object), Deleter<VkBuffer>(vk, device));
}
-Move<VkBufferViewT> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo)
+Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo)
{
VkBufferView object = 0;
VK_CHECK(vk.createBufferView(device, pCreateInfo, &object));
- return Move<VkBufferViewT>(vk, device, check<VkBufferViewT>(object));
+ return Move<VkBufferView>(check<VkBufferView>(object), Deleter<VkBufferView>(vk, device));
}
-Move<VkImageT> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo)
+Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo)
{
VkImage object = 0;
VK_CHECK(vk.createImage(device, pCreateInfo, &object));
- return Move<VkImageT>(vk, device, check<VkImageT>(object));
+ return Move<VkImage>(check<VkImage>(object), Deleter<VkImage>(vk, device));
}
-Move<VkImageViewT> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo)
+Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo)
{
VkImageView object = 0;
VK_CHECK(vk.createImageView(device, pCreateInfo, &object));
- return Move<VkImageViewT>(vk, device, check<VkImageViewT>(object));
+ return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device));
}
-Move<VkColorAttachmentViewT> createColorAttachmentView (const DeviceInterface& vk, VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo)
+Move<VkAttachmentView> createAttachmentView (const DeviceInterface& vk, VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo)
{
- VkColorAttachmentView object = 0;
- VK_CHECK(vk.createColorAttachmentView(device, pCreateInfo, &object));
- return Move<VkColorAttachmentViewT>(vk, device, check<VkColorAttachmentViewT>(object));
+ VkAttachmentView object = 0;
+ VK_CHECK(vk.createAttachmentView(device, pCreateInfo, &object));
+ return Move<VkAttachmentView>(check<VkAttachmentView>(object), Deleter<VkAttachmentView>(vk, device));
}
-Move<VkDepthStencilViewT> createDepthStencilView (const DeviceInterface& vk, VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo)
+Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo)
{
- VkDepthStencilView object = 0;
- VK_CHECK(vk.createDepthStencilView(device, pCreateInfo, &object));
- return Move<VkDepthStencilViewT>(vk, device, check<VkDepthStencilViewT>(object));
+ VkShaderModule object = 0;
+ VK_CHECK(vk.createShaderModule(device, pCreateInfo, &object));
+ return Move<VkShaderModule>(check<VkShaderModule>(object), Deleter<VkShaderModule>(vk, device));
}
-Move<VkShaderT> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo)
+Move<VkShader> createShader (const DeviceInterface& vk, VkDevice device, const VkShaderCreateInfo* pCreateInfo)
{
VkShader object = 0;
VK_CHECK(vk.createShader(device, pCreateInfo, &object));
- return Move<VkShaderT>(vk, device, check<VkShaderT>(object));
+ return Move<VkShader>(check<VkShader>(object), Deleter<VkShader>(vk, device));
}
-Move<VkPipelineT> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo)
+Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo)
{
- VkPipeline object = 0;
- VK_CHECK(vk.createGraphicsPipeline(device, pCreateInfo, &object));
- return Move<VkPipelineT>(vk, device, check<VkPipelineT>(object));
+ VkPipelineCache object = 0;
+ VK_CHECK(vk.createPipelineCache(device, pCreateInfo, &object));
+ return Move<VkPipelineCache>(check<VkPipelineCache>(object), Deleter<VkPipelineCache>(vk, device));
}
-Move<VkPipelineT> createGraphicsPipelineDerivative (const DeviceInterface& vk, VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline)
-{
- VkPipeline object = 0;
- VK_CHECK(vk.createGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, &object));
- return Move<VkPipelineT>(vk, device, check<VkPipelineT>(object));
-}
-
-Move<VkPipelineT> createComputePipeline (const DeviceInterface& vk, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo)
-{
- VkPipeline object = 0;
- VK_CHECK(vk.createComputePipeline(device, pCreateInfo, &object));
- return Move<VkPipelineT>(vk, device, check<VkPipelineT>(object));
-}
-
-Move<VkPipelineLayoutT> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo)
+Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo)
{
VkPipelineLayout object = 0;
VK_CHECK(vk.createPipelineLayout(device, pCreateInfo, &object));
- return Move<VkPipelineLayoutT>(vk, device, check<VkPipelineLayoutT>(object));
+ return Move<VkPipelineLayout>(check<VkPipelineLayout>(object), Deleter<VkPipelineLayout>(vk, device));
}
-Move<VkSamplerT> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo)
+Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo)
{
VkSampler object = 0;
VK_CHECK(vk.createSampler(device, pCreateInfo, &object));
- return Move<VkSamplerT>(vk, device, check<VkSamplerT>(object));
+ return Move<VkSampler>(check<VkSampler>(object), Deleter<VkSampler>(vk, device));
}
-Move<VkDescriptorSetLayoutT> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
+Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
{
VkDescriptorSetLayout object = 0;
VK_CHECK(vk.createDescriptorSetLayout(device, pCreateInfo, &object));
- return Move<VkDescriptorSetLayoutT>(vk, device, check<VkDescriptorSetLayoutT>(object));
+ return Move<VkDescriptorSetLayout>(check<VkDescriptorSetLayout>(object), Deleter<VkDescriptorSetLayout>(vk, device));
}
-Move<VkDescriptorPoolT> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo)
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo)
{
VkDescriptorPool object = 0;
VK_CHECK(vk.createDescriptorPool(device, poolUsage, maxSets, pCreateInfo, &object));
- return Move<VkDescriptorPoolT>(vk, device, check<VkDescriptorPoolT>(object));
+ return Move<VkDescriptorPool>(check<VkDescriptorPool>(object), Deleter<VkDescriptorPool>(vk, device));
}
-Move<VkDynamicVpStateT> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo)
+Move<VkDynamicViewportState> createDynamicViewportState (const DeviceInterface& vk, VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo)
{
- VkDynamicVpState object = 0;
+ VkDynamicViewportState object = 0;
VK_CHECK(vk.createDynamicViewportState(device, pCreateInfo, &object));
- return Move<VkDynamicVpStateT>(vk, device, check<VkDynamicVpStateT>(object));
+ return Move<VkDynamicViewportState>(check<VkDynamicViewportState>(object), Deleter<VkDynamicViewportState>(vk, device));
}
-Move<VkDynamicRsStateT> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo)
+Move<VkDynamicRasterState> createDynamicRasterState (const DeviceInterface& vk, VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo)
{
- VkDynamicRsState object = 0;
+ VkDynamicRasterState object = 0;
VK_CHECK(vk.createDynamicRasterState(device, pCreateInfo, &object));
- return Move<VkDynamicRsStateT>(vk, device, check<VkDynamicRsStateT>(object));
+ return Move<VkDynamicRasterState>(check<VkDynamicRasterState>(object), Deleter<VkDynamicRasterState>(vk, device));
}
-Move<VkDynamicCbStateT> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo)
+Move<VkDynamicColorBlendState> createDynamicColorBlendState (const DeviceInterface& vk, VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo)
{
- VkDynamicCbState object = 0;
+ VkDynamicColorBlendState object = 0;
VK_CHECK(vk.createDynamicColorBlendState(device, pCreateInfo, &object));
- return Move<VkDynamicCbStateT>(vk, device, check<VkDynamicCbStateT>(object));
+ return Move<VkDynamicColorBlendState>(check<VkDynamicColorBlendState>(object), Deleter<VkDynamicColorBlendState>(vk, device));
}
-Move<VkDynamicDsStateT> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo)
+Move<VkDynamicDepthStencilState> createDynamicDepthStencilState (const DeviceInterface& vk, VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo)
{
- VkDynamicDsState object = 0;
+ VkDynamicDepthStencilState object = 0;
VK_CHECK(vk.createDynamicDepthStencilState(device, pCreateInfo, &object));
- return Move<VkDynamicDsStateT>(vk, device, check<VkDynamicDsStateT>(object));
+ return Move<VkDynamicDepthStencilState>(check<VkDynamicDepthStencilState>(object), Deleter<VkDynamicDepthStencilState>(vk, device));
}
-Move<VkCmdBufferT> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo)
-{
- VkCmdBuffer object = 0;
- VK_CHECK(vk.createCommandBuffer(device, pCreateInfo, &object));
- return Move<VkCmdBufferT>(vk, device, check<VkCmdBufferT>(object));
-}
-
-Move<VkFramebufferT> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo)
+Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo)
{
VkFramebuffer object = 0;
VK_CHECK(vk.createFramebuffer(device, pCreateInfo, &object));
- return Move<VkFramebufferT>(vk, device, check<VkFramebufferT>(object));
+ return Move<VkFramebuffer>(check<VkFramebuffer>(object), Deleter<VkFramebuffer>(vk, device));
}
-Move<VkRenderPassT> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo)
+Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo)
{
VkRenderPass object = 0;
VK_CHECK(vk.createRenderPass(device, pCreateInfo, &object));
- return Move<VkRenderPassT>(vk, device, check<VkRenderPassT>(object));
+ return Move<VkRenderPass>(check<VkRenderPass>(object), Deleter<VkRenderPass>(vk, device));
+}
+
+Move<VkCmdPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo)
+{
+ VkCmdPool object = 0;
+ VK_CHECK(vk.createCommandPool(device, pCreateInfo, &object));
+ return Move<VkCmdPool>(check<VkCmdPool>(object), Deleter<VkCmdPool>(vk, device));
+}
+
+Move<VkCmdBuffer> createCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo)
+{
+ VkCmdBuffer object = 0;
+ VK_CHECK(vk.createCommandBuffer(device, pCreateInfo, &object));
+ return Move<VkCmdBuffer>(check<VkCmdBuffer>(object), Deleter<VkCmdBuffer>(vk, device));
}
template<typename T>
const char* getTypeName (void);
-inline std::ostream& operator<< (std::ostream& s, const ApiVersion& version)
+template<HandleType Type>
+inline std::ostream& operator<< (std::ostream& s, const Handle<Type>& handle)
{
- return s << version.major << "." << version.minor << "." << version.patch;
+ return s << tcu::toHex(handle.getInternal());
}
-inline std::ostream& operator<< (std::ostream& s, const VkClearColorValue& value)
+inline std::ostream& operator<< (std::ostream& s, const ApiVersion& version)
{
- return s << "{ floatColor = " << tcu::formatArray(DE_ARRAY_BEGIN(value.floatColor), DE_ARRAY_END(value.floatColor))
- << ", rawColor = " << tcu::formatArray(tcu::Format::HexIterator<deUint32>(DE_ARRAY_BEGIN(value.rawColor)), tcu::Format::HexIterator<deUint32>(DE_ARRAY_END(value.rawColor))) << " }";
+ return s << version.major << "." << version.minor << "." << version.patch;
}
} // vk
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-const char* getMemoryPriorityName (VkMemoryPriority value);
-const char* getImageLayoutName (VkImageLayout value);
-const char* getPipeEventName (VkPipeEvent value);
-const char* getWaitEventName (VkWaitEvent value);
-const char* getAttachmentLoadOpName (VkAttachmentLoadOp value);
-const char* getAttachmentStoreOpName (VkAttachmentStoreOp value);
-const char* getImageTypeName (VkImageType value);
-const char* getImageTilingName (VkImageTiling value);
-const char* getImageViewTypeName (VkImageViewType value);
-const char* getImageAspectName (VkImageAspect value);
-const char* getBufferViewTypeName (VkBufferViewType value);
-const char* getChannelSwizzleName (VkChannelSwizzle value);
-const char* getDescriptorTypeName (VkDescriptorType value);
-const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value);
-const char* getDescriptorUpdateModeName (VkDescriptorUpdateMode value);
-const char* getDescriptorSetUsageName (VkDescriptorSetUsage value);
-const char* getQueryTypeName (VkQueryType value);
-const char* getTimestampTypeName (VkTimestampType value);
-const char* getBorderColorName (VkBorderColor value);
-const char* getPipelineBindPointName (VkPipelineBindPoint value);
-const char* getStateBindPointName (VkStateBindPoint value);
-const char* getPrimitiveTopologyName (VkPrimitiveTopology value);
-const char* getIndexTypeName (VkIndexType value);
-const char* getTexFilterName (VkTexFilter value);
-const char* getTexMipmapModeName (VkTexMipmapMode value);
-const char* getTexAddressName (VkTexAddress value);
-const char* getCompareOpName (VkCompareOp value);
-const char* getFillModeName (VkFillMode value);
-const char* getCullModeName (VkCullMode value);
-const char* getFrontFaceName (VkFrontFace value);
-const char* getProvokingVertexName (VkProvokingVertex value);
-const char* getCoordinateOriginName (VkCoordinateOrigin value);
-const char* getDepthModeName (VkDepthMode value);
-const char* getBlendName (VkBlend value);
-const char* getBlendOpName (VkBlendOp value);
-const char* getStencilOpName (VkStencilOp value);
-const char* getLogicOpName (VkLogicOp value);
-const char* getSystemAllocTypeName (VkSystemAllocType value);
-const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value);
-const char* getPhysicalDeviceInfoTypeName (VkPhysicalDeviceInfoType value);
-const char* getExtensionInfoTypeName (VkExtensionInfoType value);
-const char* getFormatInfoTypeName (VkFormatInfoType value);
-const char* getSubresourceInfoTypeName (VkSubresourceInfoType value);
-const char* getObjectInfoTypeName (VkObjectInfoType value);
-const char* getVertexInputStepRateName (VkVertexInputStepRate value);
-const char* getFormatName (VkFormat value);
-const char* getShaderStageName (VkShaderStage value);
-const char* getStructureTypeName (VkStructureType value);
-const char* getObjectTypeName (VkObjectType value);
-const char* getResultName (VkResult value);
+const char* getResultName (VkResult value);
+const char* getStructureTypeName (VkStructureType value);
+const char* getSystemAllocTypeName (VkSystemAllocType value);
+const char* getFormatName (VkFormat value);
+const char* getImageTypeName (VkImageType value);
+const char* getImageTilingName (VkImageTiling value);
+const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value);
+const char* getImageAspectName (VkImageAspect value);
+const char* getQueryTypeName (VkQueryType value);
+const char* getSharingModeName (VkSharingMode value);
+const char* getBufferViewTypeName (VkBufferViewType value);
+const char* getImageViewTypeName (VkImageViewType value);
+const char* getChannelSwizzleName (VkChannelSwizzle value);
+const char* getShaderStageName (VkShaderStage value);
+const char* getVertexInputStepRateName (VkVertexInputStepRate value);
+const char* getPrimitiveTopologyName (VkPrimitiveTopology value);
+const char* getFillModeName (VkFillMode value);
+const char* getCullModeName (VkCullMode value);
+const char* getFrontFaceName (VkFrontFace value);
+const char* getCompareOpName (VkCompareOp value);
+const char* getStencilOpName (VkStencilOp value);
+const char* getLogicOpName (VkLogicOp value);
+const char* getBlendName (VkBlend value);
+const char* getBlendOpName (VkBlendOp value);
+const char* getTexFilterName (VkTexFilter value);
+const char* getTexMipmapModeName (VkTexMipmapMode value);
+const char* getTexAddressName (VkTexAddress value);
+const char* getBorderColorName (VkBorderColor value);
+const char* getDescriptorTypeName (VkDescriptorType value);
+const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value);
+const char* getDescriptorSetUsageName (VkDescriptorSetUsage value);
+const char* getImageLayoutName (VkImageLayout value);
+const char* getAttachmentLoadOpName (VkAttachmentLoadOp value);
+const char* getAttachmentStoreOpName (VkAttachmentStoreOp value);
+const char* getPipelineBindPointName (VkPipelineBindPoint value);
+const char* getCmdBufferLevelName (VkCmdBufferLevel value);
+const char* getIndexTypeName (VkIndexType value);
+const char* getTimestampTypeName (VkTimestampType value);
+const char* getRenderPassContentsName (VkRenderPassContents value);
-inline tcu::Format::Enum<VkMemoryPriority> getMemoryPriorityStr (VkMemoryPriority value) { return tcu::Format::Enum<VkMemoryPriority>(getMemoryPriorityName, value); }
-inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
-inline tcu::Format::Enum<VkPipeEvent> getPipeEventStr (VkPipeEvent value) { return tcu::Format::Enum<VkPipeEvent>(getPipeEventName, value); }
-inline tcu::Format::Enum<VkWaitEvent> getWaitEventStr (VkWaitEvent value) { return tcu::Format::Enum<VkWaitEvent>(getWaitEventName, value); }
-inline tcu::Format::Enum<VkAttachmentLoadOp> getAttachmentLoadOpStr (VkAttachmentLoadOp value) { return tcu::Format::Enum<VkAttachmentLoadOp>(getAttachmentLoadOpName, value); }
-inline tcu::Format::Enum<VkAttachmentStoreOp> getAttachmentStoreOpStr (VkAttachmentStoreOp value) { return tcu::Format::Enum<VkAttachmentStoreOp>(getAttachmentStoreOpName, value); }
-inline tcu::Format::Enum<VkImageType> getImageTypeStr (VkImageType value) { return tcu::Format::Enum<VkImageType>(getImageTypeName, value); }
-inline tcu::Format::Enum<VkImageTiling> getImageTilingStr (VkImageTiling value) { return tcu::Format::Enum<VkImageTiling>(getImageTilingName, value); }
-inline tcu::Format::Enum<VkImageViewType> getImageViewTypeStr (VkImageViewType value) { return tcu::Format::Enum<VkImageViewType>(getImageViewTypeName, value); }
-inline tcu::Format::Enum<VkImageAspect> getImageAspectStr (VkImageAspect value) { return tcu::Format::Enum<VkImageAspect>(getImageAspectName, value); }
-inline tcu::Format::Enum<VkBufferViewType> getBufferViewTypeStr (VkBufferViewType value) { return tcu::Format::Enum<VkBufferViewType>(getBufferViewTypeName, value); }
-inline tcu::Format::Enum<VkChannelSwizzle> getChannelSwizzleStr (VkChannelSwizzle value) { return tcu::Format::Enum<VkChannelSwizzle>(getChannelSwizzleName, value); }
-inline tcu::Format::Enum<VkDescriptorType> getDescriptorTypeStr (VkDescriptorType value) { return tcu::Format::Enum<VkDescriptorType>(getDescriptorTypeName, value); }
-inline tcu::Format::Enum<VkDescriptorPoolUsage> getDescriptorPoolUsageStr (VkDescriptorPoolUsage value) { return tcu::Format::Enum<VkDescriptorPoolUsage>(getDescriptorPoolUsageName, value); }
-inline tcu::Format::Enum<VkDescriptorUpdateMode> getDescriptorUpdateModeStr (VkDescriptorUpdateMode value) { return tcu::Format::Enum<VkDescriptorUpdateMode>(getDescriptorUpdateModeName, value); }
-inline tcu::Format::Enum<VkDescriptorSetUsage> getDescriptorSetUsageStr (VkDescriptorSetUsage value) { return tcu::Format::Enum<VkDescriptorSetUsage>(getDescriptorSetUsageName, value); }
-inline tcu::Format::Enum<VkQueryType> getQueryTypeStr (VkQueryType value) { return tcu::Format::Enum<VkQueryType>(getQueryTypeName, value); }
-inline tcu::Format::Enum<VkTimestampType> getTimestampTypeStr (VkTimestampType value) { return tcu::Format::Enum<VkTimestampType>(getTimestampTypeName, value); }
-inline tcu::Format::Enum<VkBorderColor> getBorderColorStr (VkBorderColor value) { return tcu::Format::Enum<VkBorderColor>(getBorderColorName, value); }
-inline tcu::Format::Enum<VkPipelineBindPoint> getPipelineBindPointStr (VkPipelineBindPoint value) { return tcu::Format::Enum<VkPipelineBindPoint>(getPipelineBindPointName, value); }
-inline tcu::Format::Enum<VkStateBindPoint> getStateBindPointStr (VkStateBindPoint value) { return tcu::Format::Enum<VkStateBindPoint>(getStateBindPointName, value); }
-inline tcu::Format::Enum<VkPrimitiveTopology> getPrimitiveTopologyStr (VkPrimitiveTopology value) { return tcu::Format::Enum<VkPrimitiveTopology>(getPrimitiveTopologyName, value); }
-inline tcu::Format::Enum<VkIndexType> getIndexTypeStr (VkIndexType value) { return tcu::Format::Enum<VkIndexType>(getIndexTypeName, value); }
-inline tcu::Format::Enum<VkTexFilter> getTexFilterStr (VkTexFilter value) { return tcu::Format::Enum<VkTexFilter>(getTexFilterName, value); }
-inline tcu::Format::Enum<VkTexMipmapMode> getTexMipmapModeStr (VkTexMipmapMode value) { return tcu::Format::Enum<VkTexMipmapMode>(getTexMipmapModeName, value); }
-inline tcu::Format::Enum<VkTexAddress> getTexAddressStr (VkTexAddress value) { return tcu::Format::Enum<VkTexAddress>(getTexAddressName, value); }
-inline tcu::Format::Enum<VkCompareOp> getCompareOpStr (VkCompareOp value) { return tcu::Format::Enum<VkCompareOp>(getCompareOpName, value); }
-inline tcu::Format::Enum<VkFillMode> getFillModeStr (VkFillMode value) { return tcu::Format::Enum<VkFillMode>(getFillModeName, value); }
-inline tcu::Format::Enum<VkCullMode> getCullModeStr (VkCullMode value) { return tcu::Format::Enum<VkCullMode>(getCullModeName, value); }
-inline tcu::Format::Enum<VkFrontFace> getFrontFaceStr (VkFrontFace value) { return tcu::Format::Enum<VkFrontFace>(getFrontFaceName, value); }
-inline tcu::Format::Enum<VkProvokingVertex> getProvokingVertexStr (VkProvokingVertex value) { return tcu::Format::Enum<VkProvokingVertex>(getProvokingVertexName, value); }
-inline tcu::Format::Enum<VkCoordinateOrigin> getCoordinateOriginStr (VkCoordinateOrigin value) { return tcu::Format::Enum<VkCoordinateOrigin>(getCoordinateOriginName, value); }
-inline tcu::Format::Enum<VkDepthMode> getDepthModeStr (VkDepthMode value) { return tcu::Format::Enum<VkDepthMode>(getDepthModeName, value); }
-inline tcu::Format::Enum<VkBlend> getBlendStr (VkBlend value) { return tcu::Format::Enum<VkBlend>(getBlendName, value); }
-inline tcu::Format::Enum<VkBlendOp> getBlendOpStr (VkBlendOp value) { return tcu::Format::Enum<VkBlendOp>(getBlendOpName, value); }
-inline tcu::Format::Enum<VkStencilOp> getStencilOpStr (VkStencilOp value) { return tcu::Format::Enum<VkStencilOp>(getStencilOpName, value); }
-inline tcu::Format::Enum<VkLogicOp> getLogicOpStr (VkLogicOp value) { return tcu::Format::Enum<VkLogicOp>(getLogicOpName, value); }
-inline tcu::Format::Enum<VkSystemAllocType> getSystemAllocTypeStr (VkSystemAllocType value) { return tcu::Format::Enum<VkSystemAllocType>(getSystemAllocTypeName, value); }
-inline tcu::Format::Enum<VkPhysicalDeviceType> getPhysicalDeviceTypeStr (VkPhysicalDeviceType value) { return tcu::Format::Enum<VkPhysicalDeviceType>(getPhysicalDeviceTypeName, value); }
-inline tcu::Format::Enum<VkPhysicalDeviceInfoType> getPhysicalDeviceInfoTypeStr (VkPhysicalDeviceInfoType value) { return tcu::Format::Enum<VkPhysicalDeviceInfoType>(getPhysicalDeviceInfoTypeName, value); }
-inline tcu::Format::Enum<VkExtensionInfoType> getExtensionInfoTypeStr (VkExtensionInfoType value) { return tcu::Format::Enum<VkExtensionInfoType>(getExtensionInfoTypeName, value); }
-inline tcu::Format::Enum<VkFormatInfoType> getFormatInfoTypeStr (VkFormatInfoType value) { return tcu::Format::Enum<VkFormatInfoType>(getFormatInfoTypeName, value); }
-inline tcu::Format::Enum<VkSubresourceInfoType> getSubresourceInfoTypeStr (VkSubresourceInfoType value) { return tcu::Format::Enum<VkSubresourceInfoType>(getSubresourceInfoTypeName, value); }
-inline tcu::Format::Enum<VkObjectInfoType> getObjectInfoTypeStr (VkObjectInfoType value) { return tcu::Format::Enum<VkObjectInfoType>(getObjectInfoTypeName, value); }
-inline tcu::Format::Enum<VkVertexInputStepRate> getVertexInputStepRateStr (VkVertexInputStepRate value) { return tcu::Format::Enum<VkVertexInputStepRate>(getVertexInputStepRateName, value); }
-inline tcu::Format::Enum<VkFormat> getFormatStr (VkFormat value) { return tcu::Format::Enum<VkFormat>(getFormatName, value); }
-inline tcu::Format::Enum<VkShaderStage> getShaderStageStr (VkShaderStage value) { return tcu::Format::Enum<VkShaderStage>(getShaderStageName, value); }
-inline tcu::Format::Enum<VkStructureType> getStructureTypeStr (VkStructureType value) { return tcu::Format::Enum<VkStructureType>(getStructureTypeName, value); }
-inline tcu::Format::Enum<VkObjectType> getObjectTypeStr (VkObjectType value) { return tcu::Format::Enum<VkObjectType>(getObjectTypeName, value); }
-inline tcu::Format::Enum<VkResult> getResultStr (VkResult value) { return tcu::Format::Enum<VkResult>(getResultName, value); }
+inline tcu::Format::Enum<VkResult> getResultStr (VkResult value) { return tcu::Format::Enum<VkResult>(getResultName, value); }
+inline tcu::Format::Enum<VkStructureType> getStructureTypeStr (VkStructureType value) { return tcu::Format::Enum<VkStructureType>(getStructureTypeName, value); }
+inline tcu::Format::Enum<VkSystemAllocType> getSystemAllocTypeStr (VkSystemAllocType value) { return tcu::Format::Enum<VkSystemAllocType>(getSystemAllocTypeName, value); }
+inline tcu::Format::Enum<VkFormat> getFormatStr (VkFormat value) { return tcu::Format::Enum<VkFormat>(getFormatName, value); }
+inline tcu::Format::Enum<VkImageType> getImageTypeStr (VkImageType value) { return tcu::Format::Enum<VkImageType>(getImageTypeName, value); }
+inline tcu::Format::Enum<VkImageTiling> getImageTilingStr (VkImageTiling value) { return tcu::Format::Enum<VkImageTiling>(getImageTilingName, value); }
+inline tcu::Format::Enum<VkPhysicalDeviceType> getPhysicalDeviceTypeStr (VkPhysicalDeviceType value) { return tcu::Format::Enum<VkPhysicalDeviceType>(getPhysicalDeviceTypeName, value); }
+inline tcu::Format::Enum<VkImageAspect> getImageAspectStr (VkImageAspect value) { return tcu::Format::Enum<VkImageAspect>(getImageAspectName, value); }
+inline tcu::Format::Enum<VkQueryType> getQueryTypeStr (VkQueryType value) { return tcu::Format::Enum<VkQueryType>(getQueryTypeName, value); }
+inline tcu::Format::Enum<VkSharingMode> getSharingModeStr (VkSharingMode value) { return tcu::Format::Enum<VkSharingMode>(getSharingModeName, value); }
+inline tcu::Format::Enum<VkBufferViewType> getBufferViewTypeStr (VkBufferViewType value) { return tcu::Format::Enum<VkBufferViewType>(getBufferViewTypeName, value); }
+inline tcu::Format::Enum<VkImageViewType> getImageViewTypeStr (VkImageViewType value) { return tcu::Format::Enum<VkImageViewType>(getImageViewTypeName, value); }
+inline tcu::Format::Enum<VkChannelSwizzle> getChannelSwizzleStr (VkChannelSwizzle value) { return tcu::Format::Enum<VkChannelSwizzle>(getChannelSwizzleName, value); }
+inline tcu::Format::Enum<VkShaderStage> getShaderStageStr (VkShaderStage value) { return tcu::Format::Enum<VkShaderStage>(getShaderStageName, value); }
+inline tcu::Format::Enum<VkVertexInputStepRate> getVertexInputStepRateStr (VkVertexInputStepRate value) { return tcu::Format::Enum<VkVertexInputStepRate>(getVertexInputStepRateName, value); }
+inline tcu::Format::Enum<VkPrimitiveTopology> getPrimitiveTopologyStr (VkPrimitiveTopology value) { return tcu::Format::Enum<VkPrimitiveTopology>(getPrimitiveTopologyName, value); }
+inline tcu::Format::Enum<VkFillMode> getFillModeStr (VkFillMode value) { return tcu::Format::Enum<VkFillMode>(getFillModeName, value); }
+inline tcu::Format::Enum<VkCullMode> getCullModeStr (VkCullMode value) { return tcu::Format::Enum<VkCullMode>(getCullModeName, value); }
+inline tcu::Format::Enum<VkFrontFace> getFrontFaceStr (VkFrontFace value) { return tcu::Format::Enum<VkFrontFace>(getFrontFaceName, value); }
+inline tcu::Format::Enum<VkCompareOp> getCompareOpStr (VkCompareOp value) { return tcu::Format::Enum<VkCompareOp>(getCompareOpName, value); }
+inline tcu::Format::Enum<VkStencilOp> getStencilOpStr (VkStencilOp value) { return tcu::Format::Enum<VkStencilOp>(getStencilOpName, value); }
+inline tcu::Format::Enum<VkLogicOp> getLogicOpStr (VkLogicOp value) { return tcu::Format::Enum<VkLogicOp>(getLogicOpName, value); }
+inline tcu::Format::Enum<VkBlend> getBlendStr (VkBlend value) { return tcu::Format::Enum<VkBlend>(getBlendName, value); }
+inline tcu::Format::Enum<VkBlendOp> getBlendOpStr (VkBlendOp value) { return tcu::Format::Enum<VkBlendOp>(getBlendOpName, value); }
+inline tcu::Format::Enum<VkTexFilter> getTexFilterStr (VkTexFilter value) { return tcu::Format::Enum<VkTexFilter>(getTexFilterName, value); }
+inline tcu::Format::Enum<VkTexMipmapMode> getTexMipmapModeStr (VkTexMipmapMode value) { return tcu::Format::Enum<VkTexMipmapMode>(getTexMipmapModeName, value); }
+inline tcu::Format::Enum<VkTexAddress> getTexAddressStr (VkTexAddress value) { return tcu::Format::Enum<VkTexAddress>(getTexAddressName, value); }
+inline tcu::Format::Enum<VkBorderColor> getBorderColorStr (VkBorderColor value) { return tcu::Format::Enum<VkBorderColor>(getBorderColorName, value); }
+inline tcu::Format::Enum<VkDescriptorType> getDescriptorTypeStr (VkDescriptorType value) { return tcu::Format::Enum<VkDescriptorType>(getDescriptorTypeName, value); }
+inline tcu::Format::Enum<VkDescriptorPoolUsage> getDescriptorPoolUsageStr (VkDescriptorPoolUsage value) { return tcu::Format::Enum<VkDescriptorPoolUsage>(getDescriptorPoolUsageName, value); }
+inline tcu::Format::Enum<VkDescriptorSetUsage> getDescriptorSetUsageStr (VkDescriptorSetUsage value) { return tcu::Format::Enum<VkDescriptorSetUsage>(getDescriptorSetUsageName, value); }
+inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
+inline tcu::Format::Enum<VkAttachmentLoadOp> getAttachmentLoadOpStr (VkAttachmentLoadOp value) { return tcu::Format::Enum<VkAttachmentLoadOp>(getAttachmentLoadOpName, value); }
+inline tcu::Format::Enum<VkAttachmentStoreOp> getAttachmentStoreOpStr (VkAttachmentStoreOp value) { return tcu::Format::Enum<VkAttachmentStoreOp>(getAttachmentStoreOpName, value); }
+inline tcu::Format::Enum<VkPipelineBindPoint> getPipelineBindPointStr (VkPipelineBindPoint value) { return tcu::Format::Enum<VkPipelineBindPoint>(getPipelineBindPointName, value); }
+inline tcu::Format::Enum<VkCmdBufferLevel> getCmdBufferLevelStr (VkCmdBufferLevel value) { return tcu::Format::Enum<VkCmdBufferLevel>(getCmdBufferLevelName, value); }
+inline tcu::Format::Enum<VkIndexType> getIndexTypeStr (VkIndexType value) { return tcu::Format::Enum<VkIndexType>(getIndexTypeName, value); }
+inline tcu::Format::Enum<VkTimestampType> getTimestampTypeStr (VkTimestampType value) { return tcu::Format::Enum<VkTimestampType>(getTimestampTypeName, value); }
+inline tcu::Format::Enum<VkRenderPassContents> getRenderPassContentsStr (VkRenderPassContents value) { return tcu::Format::Enum<VkRenderPassContents>(getRenderPassContentsName, value); }
-inline std::ostream& operator<< (std::ostream& s, VkMemoryPriority value) { return s << getMemoryPriorityStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPipeEvent value) { return s << getPipeEventStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkWaitEvent value) { return s << getWaitEventStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkAttachmentLoadOp value) { return s << getAttachmentLoadOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkAttachmentStoreOp value) { return s << getAttachmentStoreOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageType value) { return s << getImageTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageTiling value) { return s << getImageTilingStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageViewType value) { return s << getImageViewTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageAspect value) { return s << getImageAspectStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBufferViewType value) { return s << getBufferViewTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkChannelSwizzle value) { return s << getChannelSwizzleStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDescriptorType value) { return s << getDescriptorTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDescriptorPoolUsage value) { return s << getDescriptorPoolUsageStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDescriptorUpdateMode value) { return s << getDescriptorUpdateModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDescriptorSetUsage value) { return s << getDescriptorSetUsageStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkQueryType value) { return s << getQueryTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkTimestampType value) { return s << getTimestampTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBorderColor value) { return s << getBorderColorStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPipelineBindPoint value) { return s << getPipelineBindPointStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkStateBindPoint value) { return s << getStateBindPointStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPrimitiveTopology value) { return s << getPrimitiveTopologyStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkIndexType value) { return s << getIndexTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkTexFilter value) { return s << getTexFilterStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkTexMipmapMode value) { return s << getTexMipmapModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkTexAddress value) { return s << getTexAddressStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkCompareOp value) { return s << getCompareOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFillMode value) { return s << getFillModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkCullMode value) { return s << getCullModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFrontFace value) { return s << getFrontFaceStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkProvokingVertex value) { return s << getProvokingVertexStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkCoordinateOrigin value) { return s << getCoordinateOriginStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDepthMode value) { return s << getDepthModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBlend value) { return s << getBlendStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBlendOp value) { return s << getBlendOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkStencilOp value) { return s << getStencilOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkLogicOp value) { return s << getLogicOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSystemAllocType value) { return s << getSystemAllocTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceType value) { return s << getPhysicalDeviceTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceInfoType value) { return s << getPhysicalDeviceInfoTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkExtensionInfoType value) { return s << getExtensionInfoTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFormatInfoType value) { return s << getFormatInfoTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSubresourceInfoType value) { return s << getSubresourceInfoTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkObjectInfoType value) { return s << getObjectInfoTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkVertexInputStepRate value) { return s << getVertexInputStepRateStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFormat value) { return s << getFormatStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkShaderStage value) { return s << getShaderStageStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkStructureType value) { return s << getStructureTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkObjectType value) { return s << getObjectTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkStructureType value) { return s << getStructureTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSystemAllocType value) { return s << getSystemAllocTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFormat value) { return s << getFormatStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageType value) { return s << getImageTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageTiling value) { return s << getImageTilingStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceType value) { return s << getPhysicalDeviceTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageAspect value) { return s << getImageAspectStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkQueryType value) { return s << getQueryTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSharingMode value) { return s << getSharingModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBufferViewType value) { return s << getBufferViewTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageViewType value) { return s << getImageViewTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkChannelSwizzle value) { return s << getChannelSwizzleStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkShaderStage value) { return s << getShaderStageStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkVertexInputStepRate value) { return s << getVertexInputStepRateStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPrimitiveTopology value) { return s << getPrimitiveTopologyStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFillMode value) { return s << getFillModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCullMode value) { return s << getCullModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFrontFace value) { return s << getFrontFaceStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCompareOp value) { return s << getCompareOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkStencilOp value) { return s << getStencilOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkLogicOp value) { return s << getLogicOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBlend value) { return s << getBlendStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBlendOp value) { return s << getBlendOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkTexFilter value) { return s << getTexFilterStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkTexMipmapMode value) { return s << getTexMipmapModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkTexAddress value) { return s << getTexAddressStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBorderColor value) { return s << getBorderColorStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDescriptorType value) { return s << getDescriptorTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDescriptorPoolUsage value) { return s << getDescriptorPoolUsageStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDescriptorSetUsage value) { return s << getDescriptorSetUsageStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkAttachmentLoadOp value) { return s << getAttachmentLoadOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkAttachmentStoreOp value) { return s << getAttachmentStoreOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPipelineBindPoint value) { return s << getPipelineBindPointStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCmdBufferLevel value) { return s << getCmdBufferLevelStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkIndexType value) { return s << getIndexTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkTimestampType value) { return s << getTimestampTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkRenderPassContents value) { return s << getRenderPassContentsStr(value); }
-tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value);
-tcu::Format::Bitfield<32> getQueueFlagsStr (VkQueueFlags value);
-tcu::Format::Bitfield<32> getMemoryPropertyFlagsStr (VkMemoryPropertyFlags value);
-tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value);
-tcu::Format::Bitfield<32> getMemoryInputFlagsStr (VkMemoryInputFlags value);
-tcu::Format::Bitfield<32> getBufferUsageFlagsStr (VkBufferUsageFlags value);
-tcu::Format::Bitfield<32> getBufferCreateFlagsStr (VkBufferCreateFlags value);
-tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value);
-tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value);
-tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value);
-tcu::Format::Bitfield<32> getDepthStencilViewCreateFlagsStr (VkDepthStencilViewCreateFlags value);
-tcu::Format::Bitfield<32> getPipelineCreateFlagsStr (VkPipelineCreateFlags value);
-tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value);
-tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value);
-tcu::Format::Bitfield<32> getSemaphoreCreateFlagsStr (VkSemaphoreCreateFlags value);
-tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value);
-tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value);
-tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value);
-tcu::Format::Bitfield<32> getPhysicalDeviceCompatibilityFlagsStr (VkPhysicalDeviceCompatibilityFlags value);
-tcu::Format::Bitfield<32> getCmdBufferOptimizeFlagsStr (VkCmdBufferOptimizeFlags value);
-tcu::Format::Bitfield<32> getQueryPipelineStatisticFlagsStr (VkQueryPipelineStatisticFlags value);
+tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value);
+tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value);
+tcu::Format::Bitfield<32> getQueueFlagsStr (VkQueueFlags value);
+tcu::Format::Bitfield<32> getMemoryPropertyFlagsStr (VkMemoryPropertyFlags value);
+tcu::Format::Bitfield<32> getMemoryHeapFlagsStr (VkMemoryHeapFlags value);
+tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value);
+tcu::Format::Bitfield<32> getSparseImageFormatFlagsStr (VkSparseImageFormatFlags value);
+tcu::Format::Bitfield<32> getSparseMemoryBindFlagsStr (VkSparseMemoryBindFlags value);
+tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value);
+tcu::Format::Bitfield<32> getQueryPipelineStatisticFlagsStr (VkQueryPipelineStatisticFlags value);
+tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value);
+tcu::Format::Bitfield<32> getBufferUsageFlagsStr (VkBufferUsageFlags value);
+tcu::Format::Bitfield<32> getBufferCreateFlagsStr (VkBufferCreateFlags value);
+tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value);
+tcu::Format::Bitfield<32> getAttachmentViewCreateFlagsStr (VkAttachmentViewCreateFlags value);
+tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value);
+tcu::Format::Bitfield<32> getPipelineCreateFlagsStr (VkPipelineCreateFlags value);
+tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value);
+tcu::Format::Bitfield<32> getSubpassDescriptionFlagsStr (VkSubpassDescriptionFlags value);
+tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value);
+tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value);
+tcu::Format::Bitfield<32> getMemoryInputFlagsStr (VkMemoryInputFlags value);
+tcu::Format::Bitfield<32> getCmdPoolCreateFlagsStr (VkCmdPoolCreateFlags value);
+tcu::Format::Bitfield<32> getCmdPoolResetFlagsStr (VkCmdPoolResetFlags value);
+tcu::Format::Bitfield<32> getCmdBufferOptimizeFlagsStr (VkCmdBufferOptimizeFlags value);
+tcu::Format::Bitfield<32> getCmdBufferResetFlagsStr (VkCmdBufferResetFlags value);
+tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value);
+tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value);
-std::ostream& operator<< (std::ostream& s, const VkOffset2D& value);
-std::ostream& operator<< (std::ostream& s, const VkOffset3D& value);
-std::ostream& operator<< (std::ostream& s, const VkExtent2D& value);
-std::ostream& operator<< (std::ostream& s, const VkExtent3D& value);
-std::ostream& operator<< (std::ostream& s, const VkViewport& value);
-std::ostream& operator<< (std::ostream& s, const VkRect& value);
-std::ostream& operator<< (std::ostream& s, const VkChannelMapping& value);
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceProperties& value);
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePerformance& value);
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceCompatibilityInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkExtensionProperties& value);
std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value);
std::ostream& operator<< (std::ostream& s, const VkAllocCallbacks& value);
-std::ostream& operator<< (std::ostream& s, const VkDeviceQueueCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDeviceCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkInstanceCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkLayerCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceFeatures& value);
+std::ostream& operator<< (std::ostream& s, const VkFormatProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkImageFormatProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceLimits& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceProperties& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceQueueProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkMemoryType& value);
+std::ostream& operator<< (std::ostream& s, const VkMemoryHeap& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkDeviceQueueCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDeviceCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkExtensionProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkLayerProperties& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryAllocInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkMemoryOpenInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPeerMemoryOpenInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkMappedMemoryRange& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryRequirements& value);
-std::ostream& operator<< (std::ostream& s, const VkFormatProperties& value);
-std::ostream& operator<< (std::ostream& s, const VkBufferViewAttachInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkImageViewAttachInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkUpdateSamplers& value);
-std::ostream& operator<< (std::ostream& s, const VkSamplerImageViewInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkUpdateSamplerTextures& value);
-std::ostream& operator<< (std::ostream& s, const VkUpdateImages& value);
-std::ostream& operator<< (std::ostream& s, const VkUpdateBuffers& value);
-std::ostream& operator<< (std::ostream& s, const VkUpdateAsCopy& value);
+std::ostream& operator<< (std::ostream& s, const VkExtent3D& value);
+std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties& value);
+std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryRequirements& value);
+std::ostream& operator<< (std::ostream& s, const VkSparseMemoryBindInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkImageSubresource& value);
+std::ostream& operator<< (std::ostream& s, const VkOffset3D& value);
+std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryBindInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkFenceCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkSemaphoreCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkEventCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkQueryPoolCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkBufferCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkBufferViewCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkImageSubresource& value);
-std::ostream& operator<< (std::ostream& s, const VkImageSubresourceRange& value);
-std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value);
-std::ostream& operator<< (std::ostream& s, const VkBufferMemoryBarrier& value);
-std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value);
std::ostream& operator<< (std::ostream& s, const VkImageCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPeerImageOpenInfo& value);
std::ostream& operator<< (std::ostream& s, const VkSubresourceLayout& value);
+std::ostream& operator<< (std::ostream& s, const VkChannelMapping& value);
+std::ostream& operator<< (std::ostream& s, const VkImageSubresourceRange& value);
std::ostream& operator<< (std::ostream& s, const VkImageViewCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkColorAttachmentViewCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDepthStencilViewCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkColorAttachmentBindInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDepthStencilBindInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value);
-std::ostream& operator<< (std::ostream& s, const VkImageMemoryBindInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkImageCopy& value);
-std::ostream& operator<< (std::ostream& s, const VkImageBlit& value);
-std::ostream& operator<< (std::ostream& s, const VkBufferImageCopy& value);
-std::ostream& operator<< (std::ostream& s, const VkImageResolve& value);
+std::ostream& operator<< (std::ostream& s, const VkAttachmentViewCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkShaderModuleCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkShaderCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDescriptorSetLayoutBinding& value);
-std::ostream& operator<< (std::ostream& s, const VkDescriptorSetLayoutCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDescriptorTypeCount& value);
-std::ostream& operator<< (std::ostream& s, const VkDescriptorPoolCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkLinkConstBuffer& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineCacheCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkSpecializationMapEntry& value);
std::ostream& operator<< (std::ostream& s, const VkSpecializationInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineShader& value);
-std::ostream& operator<< (std::ostream& s, const VkComputePipelineCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineShaderStageCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkVertexInputBindingDescription& value);
std::ostream& operator<< (std::ostream& s, const VkVertexInputAttributeDescription& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineVertexInputCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineIaStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineTessStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineVpStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineRsStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineMsStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineCbAttachmentState& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineCbStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineVertexInputStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineInputAssemblyStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineTessellationStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineViewportStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineRasterStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineMultisampleStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkStencilOpState& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineDsStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkPipelineShaderStageCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineDepthStencilStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendAttachmentState& value);
+std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendStateCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkGraphicsPipelineCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkComputePipelineCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkPushConstantRange& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineLayoutCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkSamplerCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicVpStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicRsStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicCbStateCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDynamicDsStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDescriptorSetLayoutBinding& value);
+std::ostream& operator<< (std::ostream& s, const VkDescriptorSetLayoutCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDescriptorTypeCount& value);
+std::ostream& operator<< (std::ostream& s, const VkDescriptorPoolCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDescriptorInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkWriteDescriptorSet& value);
+std::ostream& operator<< (std::ostream& s, const VkCopyDescriptorSet& value);
+std::ostream& operator<< (std::ostream& s, const VkViewport& value);
+std::ostream& operator<< (std::ostream& s, const VkOffset2D& value);
+std::ostream& operator<< (std::ostream& s, const VkExtent2D& value);
+std::ostream& operator<< (std::ostream& s, const VkRect2D& value);
+std::ostream& operator<< (std::ostream& s, const VkDynamicViewportStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDynamicRasterStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDynamicColorBlendStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkDynamicDepthStencilStateCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkAttachmentBindInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkFramebufferCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkAttachmentDescription& value);
+std::ostream& operator<< (std::ostream& s, const VkAttachmentReference& value);
+std::ostream& operator<< (std::ostream& s, const VkSubpassDescription& value);
+std::ostream& operator<< (std::ostream& s, const VkSubpassDependency& value);
+std::ostream& operator<< (std::ostream& s, const VkRenderPassCreateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkCmdPoolCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkCmdBufferCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkCmdBufferBeginInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkRenderPassBegin& value);
-std::ostream& operator<< (std::ostream& s, const VkCmdBufferGraphicsBeginInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkClearColor& value);
-std::ostream& operator<< (std::ostream& s, const VkRenderPassCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkEventCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkFenceCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkSemaphoreCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkSemaphoreOpenInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkQueryPoolCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkFramebufferCreateInfo& value);
-std::ostream& operator<< (std::ostream& s, const VkDrawIndirectCmd& value);
-std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCmd& value);
+std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value);
+std::ostream& operator<< (std::ostream& s, const VkImageCopy& value);
+std::ostream& operator<< (std::ostream& s, const VkImageBlit& value);
+std::ostream& operator<< (std::ostream& s, const VkBufferImageCopy& value);
+std::ostream& operator<< (std::ostream& s, const VkClearColorValue& value);
+std::ostream& operator<< (std::ostream& s, const VkRect3D& value);
+std::ostream& operator<< (std::ostream& s, const VkImageResolve& value);
+std::ostream& operator<< (std::ostream& s, const VkClearDepthStencilValue& value);
+std::ostream& operator<< (std::ostream& s, const VkClearValue& value);
+std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkBufferMemoryBarrier& value);
std::ostream& operator<< (std::ostream& s, const VkDispatchIndirectCmd& value);
+std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCmd& value);
+std::ostream& operator<< (std::ostream& s, const VkDrawIndirectCmd& value);
+std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value);
+std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value);
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-template<> const char* getTypeName<VkObjectT> (void) { return "VkObject"; }
-template<> const char* getTypeName<VkInstanceT> (void) { return "VkInstance"; }
-template<> const char* getTypeName<VkPhysicalDeviceT> (void) { return "VkPhysicalDevice"; }
-template<> const char* getTypeName<VkDeviceT> (void) { return "VkDevice"; }
-template<> const char* getTypeName<VkQueueT> (void) { return "VkQueue"; }
-template<> const char* getTypeName<VkCmdBufferT> (void) { return "VkCmdBuffer"; }
-template<> const char* getTypeName<VkNonDispatchableT> (void) { return "VkNonDispatchable"; }
-template<> const char* getTypeName<VkDeviceMemoryT> (void) { return "VkDeviceMemory"; }
-template<> const char* getTypeName<VkBufferT> (void) { return "VkBuffer"; }
-template<> const char* getTypeName<VkBufferViewT> (void) { return "VkBufferView"; }
-template<> const char* getTypeName<VkImageT> (void) { return "VkImage"; }
-template<> const char* getTypeName<VkImageViewT> (void) { return "VkImageView"; }
-template<> const char* getTypeName<VkColorAttachmentViewT> (void) { return "VkColorAttachmentView"; }
-template<> const char* getTypeName<VkDepthStencilViewT> (void) { return "VkDepthStencilView"; }
-template<> const char* getTypeName<VkShaderT> (void) { return "VkShader"; }
-template<> const char* getTypeName<VkPipelineT> (void) { return "VkPipeline"; }
-template<> const char* getTypeName<VkPipelineLayoutT> (void) { return "VkPipelineLayout"; }
-template<> const char* getTypeName<VkSamplerT> (void) { return "VkSampler"; }
-template<> const char* getTypeName<VkDescriptorSetT> (void) { return "VkDescriptorSet"; }
-template<> const char* getTypeName<VkDescriptorSetLayoutT> (void) { return "VkDescriptorSetLayout"; }
-template<> const char* getTypeName<VkDescriptorPoolT> (void) { return "VkDescriptorPool"; }
-template<> const char* getTypeName<VkDynamicStateObjectT> (void) { return "VkDynamicStateObject"; }
-template<> const char* getTypeName<VkDynamicVpStateT> (void) { return "VkDynamicVpState"; }
-template<> const char* getTypeName<VkDynamicRsStateT> (void) { return "VkDynamicRsState"; }
-template<> const char* getTypeName<VkDynamicCbStateT> (void) { return "VkDynamicCbState"; }
-template<> const char* getTypeName<VkDynamicDsStateT> (void) { return "VkDynamicDsState"; }
-template<> const char* getTypeName<VkFenceT> (void) { return "VkFence"; }
-template<> const char* getTypeName<VkSemaphoreT> (void) { return "VkSemaphore"; }
-template<> const char* getTypeName<VkEventT> (void) { return "VkEvent"; }
-template<> const char* getTypeName<VkQueryPoolT> (void) { return "VkQueryPool"; }
-template<> const char* getTypeName<VkFramebufferT> (void) { return "VkFramebuffer"; }
-template<> const char* getTypeName<VkRenderPassT> (void) { return "VkRenderPass"; }
-
-const char* getMemoryPriorityName (VkMemoryPriority value)
-{
- switch (value)
- {
- case VK_MEMORY_PRIORITY_UNUSED: return "VK_MEMORY_PRIORITY_UNUSED";
- case VK_MEMORY_PRIORITY_VERY_LOW: return "VK_MEMORY_PRIORITY_VERY_LOW";
- case VK_MEMORY_PRIORITY_LOW: return "VK_MEMORY_PRIORITY_LOW";
- case VK_MEMORY_PRIORITY_NORMAL: return "VK_MEMORY_PRIORITY_NORMAL";
- case VK_MEMORY_PRIORITY_HIGH: return "VK_MEMORY_PRIORITY_HIGH";
- case VK_MEMORY_PRIORITY_VERY_HIGH: return "VK_MEMORY_PRIORITY_VERY_HIGH";
- default: return DE_NULL;
- }
-}
+template<> const char* getTypeName<VkInstance> (void) { return "VkInstance"; }
+template<> const char* getTypeName<VkPhysicalDevice> (void) { return "VkPhysicalDevice"; }
+template<> const char* getTypeName<VkDevice> (void) { return "VkDevice"; }
+template<> const char* getTypeName<VkQueue> (void) { return "VkQueue"; }
+template<> const char* getTypeName<VkCmdBuffer> (void) { return "VkCmdBuffer"; }
+template<> const char* getTypeName<VkFence> (void) { return "VkFence"; }
+template<> const char* getTypeName<VkDeviceMemory> (void) { return "VkDeviceMemory"; }
+template<> const char* getTypeName<VkBuffer> (void) { return "VkBuffer"; }
+template<> const char* getTypeName<VkImage> (void) { return "VkImage"; }
+template<> const char* getTypeName<VkSemaphore> (void) { return "VkSemaphore"; }
+template<> const char* getTypeName<VkEvent> (void) { return "VkEvent"; }
+template<> const char* getTypeName<VkQueryPool> (void) { return "VkQueryPool"; }
+template<> const char* getTypeName<VkBufferView> (void) { return "VkBufferView"; }
+template<> const char* getTypeName<VkImageView> (void) { return "VkImageView"; }
+template<> const char* getTypeName<VkAttachmentView> (void) { return "VkAttachmentView"; }
+template<> const char* getTypeName<VkShaderModule> (void) { return "VkShaderModule"; }
+template<> const char* getTypeName<VkShader> (void) { return "VkShader"; }
+template<> const char* getTypeName<VkPipelineCache> (void) { return "VkPipelineCache"; }
+template<> const char* getTypeName<VkPipelineLayout> (void) { return "VkPipelineLayout"; }
+template<> const char* getTypeName<VkRenderPass> (void) { return "VkRenderPass"; }
+template<> const char* getTypeName<VkPipeline> (void) { return "VkPipeline"; }
+template<> const char* getTypeName<VkDescriptorSetLayout> (void) { return "VkDescriptorSetLayout"; }
+template<> const char* getTypeName<VkSampler> (void) { return "VkSampler"; }
+template<> const char* getTypeName<VkDescriptorPool> (void) { return "VkDescriptorPool"; }
+template<> const char* getTypeName<VkDescriptorSet> (void) { return "VkDescriptorSet"; }
+template<> const char* getTypeName<VkDynamicViewportState> (void) { return "VkDynamicViewportState"; }
+template<> const char* getTypeName<VkDynamicRasterState> (void) { return "VkDynamicRasterState"; }
+template<> const char* getTypeName<VkDynamicColorBlendState> (void) { return "VkDynamicColorBlendState"; }
+template<> const char* getTypeName<VkDynamicDepthStencilState> (void) { return "VkDynamicDepthStencilState"; }
+template<> const char* getTypeName<VkFramebuffer> (void) { return "VkFramebuffer"; }
+template<> const char* getTypeName<VkCmdPool> (void) { return "VkCmdPool"; }
-const char* getImageLayoutName (VkImageLayout value)
+const char* getResultName (VkResult value)
{
switch (value)
{
- case VK_IMAGE_LAYOUT_UNDEFINED: return "VK_IMAGE_LAYOUT_UNDEFINED";
- case VK_IMAGE_LAYOUT_GENERAL: return "VK_IMAGE_LAYOUT_GENERAL";
- case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case VK_IMAGE_LAYOUT_CLEAR_OPTIMAL: return "VK_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
- case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- default: return DE_NULL;
+ case VK_SUCCESS: return "VK_SUCCESS";
+ case VK_UNSUPPORTED: return "VK_UNSUPPORTED";
+ case VK_NOT_READY: return "VK_NOT_READY";
+ case VK_TIMEOUT: return "VK_TIMEOUT";
+ case VK_EVENT_SET: return "VK_EVENT_SET";
+ case VK_EVENT_RESET: return "VK_EVENT_RESET";
+ case VK_INCOMPLETE: return "VK_INCOMPLETE";
+ case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN";
+ case VK_ERROR_UNAVAILABLE: return "VK_ERROR_UNAVAILABLE";
+ case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
+ case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY";
+ case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
+ case VK_ERROR_DEVICE_ALREADY_CREATED: return "VK_ERROR_DEVICE_ALREADY_CREATED";
+ case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
+ case VK_ERROR_INVALID_POINTER: return "VK_ERROR_INVALID_POINTER";
+ case VK_ERROR_INVALID_VALUE: return "VK_ERROR_INVALID_VALUE";
+ case VK_ERROR_INVALID_HANDLE: return "VK_ERROR_INVALID_HANDLE";
+ case VK_ERROR_INVALID_ORDINAL: return "VK_ERROR_INVALID_ORDINAL";
+ case VK_ERROR_INVALID_MEMORY_SIZE: return "VK_ERROR_INVALID_MEMORY_SIZE";
+ case VK_ERROR_INVALID_EXTENSION: return "VK_ERROR_INVALID_EXTENSION";
+ case VK_ERROR_INVALID_FLAGS: return "VK_ERROR_INVALID_FLAGS";
+ case VK_ERROR_INVALID_ALIGNMENT: return "VK_ERROR_INVALID_ALIGNMENT";
+ case VK_ERROR_INVALID_FORMAT: return "VK_ERROR_INVALID_FORMAT";
+ case VK_ERROR_INVALID_IMAGE: return "VK_ERROR_INVALID_IMAGE";
+ case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA: return "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+ case VK_ERROR_INVALID_QUEUE_TYPE: return "VK_ERROR_INVALID_QUEUE_TYPE";
+ case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION: return "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+ case VK_ERROR_BAD_SHADER_CODE: return "VK_ERROR_BAD_SHADER_CODE";
+ case VK_ERROR_BAD_PIPELINE_DATA: return "VK_ERROR_BAD_PIPELINE_DATA";
+ case VK_ERROR_NOT_MAPPABLE: return "VK_ERROR_NOT_MAPPABLE";
+ case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
+ case VK_ERROR_MEMORY_UNMAP_FAILED: return "VK_ERROR_MEMORY_UNMAP_FAILED";
+ case VK_ERROR_INCOMPATIBLE_DEVICE: return "VK_ERROR_INCOMPATIBLE_DEVICE";
+ case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
+ case VK_ERROR_INCOMPLETE_COMMAND_BUFFER: return "VK_ERROR_INCOMPLETE_COMMAND_BUFFER";
+ case VK_ERROR_BUILDING_COMMAND_BUFFER: return "VK_ERROR_BUILDING_COMMAND_BUFFER";
+ case VK_ERROR_MEMORY_NOT_BOUND: return "VK_ERROR_MEMORY_NOT_BOUND";
+ case VK_ERROR_INCOMPATIBLE_QUEUE: return "VK_ERROR_INCOMPATIBLE_QUEUE";
+ case VK_ERROR_INVALID_LAYER: return "VK_ERROR_INVALID_LAYER";
+ default: return DE_NULL;
}
}
-const char* getPipeEventName (VkPipeEvent value)
+const char* getStructureTypeName (VkStructureType value)
{
switch (value)
{
- case VK_PIPE_EVENT_TOP_OF_PIPE: return "VK_PIPE_EVENT_TOP_OF_PIPE";
- case VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE: return "VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE";
- case VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE: return "VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE";
- case VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE: return "VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE";
- case VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE: return "VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE";
- case VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE: return "VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE";
- case VK_PIPE_EVENT_TRANSFER_COMPLETE: return "VK_PIPE_EVENT_TRANSFER_COMPLETE";
- case VK_PIPE_EVENT_COMMANDS_COMPLETE: return "VK_PIPE_EVENT_COMMANDS_COMPLETE";
- default: return DE_NULL;
+ case VK_STRUCTURE_TYPE_APPLICATION_INFO: return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: return "VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_LAYER_CREATE_INFO: return "VK_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
+ case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
+ case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
+ case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION: return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION";
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION: return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION";
+ case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY: return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO";
+ default: return DE_NULL;
}
}
-const char* getWaitEventName (VkWaitEvent value)
+const char* getSystemAllocTypeName (VkSystemAllocType value)
{
switch (value)
{
- case VK_WAIT_EVENT_TOP_OF_PIPE: return "VK_WAIT_EVENT_TOP_OF_PIPE";
- case VK_WAIT_EVENT_BEFORE_RASTERIZATION: return "VK_WAIT_EVENT_BEFORE_RASTERIZATION";
+ case VK_SYSTEM_ALLOC_TYPE_API_OBJECT: return "VK_SYSTEM_ALLOC_TYPE_API_OBJECT";
+ case VK_SYSTEM_ALLOC_TYPE_INTERNAL: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL";
+ case VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP";
+ case VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER";
+ case VK_SYSTEM_ALLOC_TYPE_DEBUG: return "VK_SYSTEM_ALLOC_TYPE_DEBUG";
default: return DE_NULL;
}
}
-const char* getAttachmentLoadOpName (VkAttachmentLoadOp value)
+const char* getFormatName (VkFormat value)
{
switch (value)
{
- case VK_ATTACHMENT_LOAD_OP_LOAD: return "VK_ATTACHMENT_LOAD_OP_LOAD";
- case VK_ATTACHMENT_LOAD_OP_CLEAR: return "VK_ATTACHMENT_LOAD_OP_CLEAR";
- case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case VK_FORMAT_UNDEFINED: return "VK_FORMAT_UNDEFINED";
+ case VK_FORMAT_R4G4_UNORM: return "VK_FORMAT_R4G4_UNORM";
+ case VK_FORMAT_R4G4_USCALED: return "VK_FORMAT_R4G4_USCALED";
+ case VK_FORMAT_R4G4B4A4_UNORM: return "VK_FORMAT_R4G4B4A4_UNORM";
+ case VK_FORMAT_R4G4B4A4_USCALED: return "VK_FORMAT_R4G4B4A4_USCALED";
+ case VK_FORMAT_R5G6B5_UNORM: return "VK_FORMAT_R5G6B5_UNORM";
+ case VK_FORMAT_R5G6B5_USCALED: return "VK_FORMAT_R5G6B5_USCALED";
+ case VK_FORMAT_R5G5B5A1_UNORM: return "VK_FORMAT_R5G5B5A1_UNORM";
+ case VK_FORMAT_R5G5B5A1_USCALED: return "VK_FORMAT_R5G5B5A1_USCALED";
+ case VK_FORMAT_R8_UNORM: return "VK_FORMAT_R8_UNORM";
+ case VK_FORMAT_R8_SNORM: return "VK_FORMAT_R8_SNORM";
+ case VK_FORMAT_R8_USCALED: return "VK_FORMAT_R8_USCALED";
+ case VK_FORMAT_R8_SSCALED: return "VK_FORMAT_R8_SSCALED";
+ case VK_FORMAT_R8_UINT: return "VK_FORMAT_R8_UINT";
+ case VK_FORMAT_R8_SINT: return "VK_FORMAT_R8_SINT";
+ case VK_FORMAT_R8_SRGB: return "VK_FORMAT_R8_SRGB";
+ case VK_FORMAT_R8G8_UNORM: return "VK_FORMAT_R8G8_UNORM";
+ case VK_FORMAT_R8G8_SNORM: return "VK_FORMAT_R8G8_SNORM";
+ case VK_FORMAT_R8G8_USCALED: return "VK_FORMAT_R8G8_USCALED";
+ case VK_FORMAT_R8G8_SSCALED: return "VK_FORMAT_R8G8_SSCALED";
+ case VK_FORMAT_R8G8_UINT: return "VK_FORMAT_R8G8_UINT";
+ case VK_FORMAT_R8G8_SINT: return "VK_FORMAT_R8G8_SINT";
+ case VK_FORMAT_R8G8_SRGB: return "VK_FORMAT_R8G8_SRGB";
+ case VK_FORMAT_R8G8B8_UNORM: return "VK_FORMAT_R8G8B8_UNORM";
+ case VK_FORMAT_R8G8B8_SNORM: return "VK_FORMAT_R8G8B8_SNORM";
+ case VK_FORMAT_R8G8B8_USCALED: return "VK_FORMAT_R8G8B8_USCALED";
+ case VK_FORMAT_R8G8B8_SSCALED: return "VK_FORMAT_R8G8B8_SSCALED";
+ case VK_FORMAT_R8G8B8_UINT: return "VK_FORMAT_R8G8B8_UINT";
+ case VK_FORMAT_R8G8B8_SINT: return "VK_FORMAT_R8G8B8_SINT";
+ case VK_FORMAT_R8G8B8_SRGB: return "VK_FORMAT_R8G8B8_SRGB";
+ case VK_FORMAT_R8G8B8A8_UNORM: return "VK_FORMAT_R8G8B8A8_UNORM";
+ case VK_FORMAT_R8G8B8A8_SNORM: return "VK_FORMAT_R8G8B8A8_SNORM";
+ case VK_FORMAT_R8G8B8A8_USCALED: return "VK_FORMAT_R8G8B8A8_USCALED";
+ case VK_FORMAT_R8G8B8A8_SSCALED: return "VK_FORMAT_R8G8B8A8_SSCALED";
+ case VK_FORMAT_R8G8B8A8_UINT: return "VK_FORMAT_R8G8B8A8_UINT";
+ case VK_FORMAT_R8G8B8A8_SINT: return "VK_FORMAT_R8G8B8A8_SINT";
+ case VK_FORMAT_R8G8B8A8_SRGB: return "VK_FORMAT_R8G8B8A8_SRGB";
+ case VK_FORMAT_R10G10B10A2_UNORM: return "VK_FORMAT_R10G10B10A2_UNORM";
+ case VK_FORMAT_R10G10B10A2_SNORM: return "VK_FORMAT_R10G10B10A2_SNORM";
+ case VK_FORMAT_R10G10B10A2_USCALED: return "VK_FORMAT_R10G10B10A2_USCALED";
+ case VK_FORMAT_R10G10B10A2_SSCALED: return "VK_FORMAT_R10G10B10A2_SSCALED";
+ case VK_FORMAT_R10G10B10A2_UINT: return "VK_FORMAT_R10G10B10A2_UINT";
+ case VK_FORMAT_R10G10B10A2_SINT: return "VK_FORMAT_R10G10B10A2_SINT";
+ case VK_FORMAT_R16_UNORM: return "VK_FORMAT_R16_UNORM";
+ case VK_FORMAT_R16_SNORM: return "VK_FORMAT_R16_SNORM";
+ case VK_FORMAT_R16_USCALED: return "VK_FORMAT_R16_USCALED";
+ case VK_FORMAT_R16_SSCALED: return "VK_FORMAT_R16_SSCALED";
+ case VK_FORMAT_R16_UINT: return "VK_FORMAT_R16_UINT";
+ case VK_FORMAT_R16_SINT: return "VK_FORMAT_R16_SINT";
+ case VK_FORMAT_R16_SFLOAT: return "VK_FORMAT_R16_SFLOAT";
+ case VK_FORMAT_R16G16_UNORM: return "VK_FORMAT_R16G16_UNORM";
+ case VK_FORMAT_R16G16_SNORM: return "VK_FORMAT_R16G16_SNORM";
+ case VK_FORMAT_R16G16_USCALED: return "VK_FORMAT_R16G16_USCALED";
+ case VK_FORMAT_R16G16_SSCALED: return "VK_FORMAT_R16G16_SSCALED";
+ case VK_FORMAT_R16G16_UINT: return "VK_FORMAT_R16G16_UINT";
+ case VK_FORMAT_R16G16_SINT: return "VK_FORMAT_R16G16_SINT";
+ case VK_FORMAT_R16G16_SFLOAT: return "VK_FORMAT_R16G16_SFLOAT";
+ case VK_FORMAT_R16G16B16_UNORM: return "VK_FORMAT_R16G16B16_UNORM";
+ case VK_FORMAT_R16G16B16_SNORM: return "VK_FORMAT_R16G16B16_SNORM";
+ case VK_FORMAT_R16G16B16_USCALED: return "VK_FORMAT_R16G16B16_USCALED";
+ case VK_FORMAT_R16G16B16_SSCALED: return "VK_FORMAT_R16G16B16_SSCALED";
+ case VK_FORMAT_R16G16B16_UINT: return "VK_FORMAT_R16G16B16_UINT";
+ case VK_FORMAT_R16G16B16_SINT: return "VK_FORMAT_R16G16B16_SINT";
+ case VK_FORMAT_R16G16B16_SFLOAT: return "VK_FORMAT_R16G16B16_SFLOAT";
+ case VK_FORMAT_R16G16B16A16_UNORM: return "VK_FORMAT_R16G16B16A16_UNORM";
+ case VK_FORMAT_R16G16B16A16_SNORM: return "VK_FORMAT_R16G16B16A16_SNORM";
+ case VK_FORMAT_R16G16B16A16_USCALED: return "VK_FORMAT_R16G16B16A16_USCALED";
+ case VK_FORMAT_R16G16B16A16_SSCALED: return "VK_FORMAT_R16G16B16A16_SSCALED";
+ case VK_FORMAT_R16G16B16A16_UINT: return "VK_FORMAT_R16G16B16A16_UINT";
+ case VK_FORMAT_R16G16B16A16_SINT: return "VK_FORMAT_R16G16B16A16_SINT";
+ case VK_FORMAT_R16G16B16A16_SFLOAT: return "VK_FORMAT_R16G16B16A16_SFLOAT";
+ case VK_FORMAT_R32_UINT: return "VK_FORMAT_R32_UINT";
+ case VK_FORMAT_R32_SINT: return "VK_FORMAT_R32_SINT";
+ case VK_FORMAT_R32_SFLOAT: return "VK_FORMAT_R32_SFLOAT";
+ case VK_FORMAT_R32G32_UINT: return "VK_FORMAT_R32G32_UINT";
+ case VK_FORMAT_R32G32_SINT: return "VK_FORMAT_R32G32_SINT";
+ case VK_FORMAT_R32G32_SFLOAT: return "VK_FORMAT_R32G32_SFLOAT";
+ case VK_FORMAT_R32G32B32_UINT: return "VK_FORMAT_R32G32B32_UINT";
+ case VK_FORMAT_R32G32B32_SINT: return "VK_FORMAT_R32G32B32_SINT";
+ case VK_FORMAT_R32G32B32_SFLOAT: return "VK_FORMAT_R32G32B32_SFLOAT";
+ case VK_FORMAT_R32G32B32A32_UINT: return "VK_FORMAT_R32G32B32A32_UINT";
+ case VK_FORMAT_R32G32B32A32_SINT: return "VK_FORMAT_R32G32B32A32_SINT";
+ case VK_FORMAT_R32G32B32A32_SFLOAT: return "VK_FORMAT_R32G32B32A32_SFLOAT";
+ case VK_FORMAT_R64_SFLOAT: return "VK_FORMAT_R64_SFLOAT";
+ case VK_FORMAT_R64G64_SFLOAT: return "VK_FORMAT_R64G64_SFLOAT";
+ case VK_FORMAT_R64G64B64_SFLOAT: return "VK_FORMAT_R64G64B64_SFLOAT";
+ case VK_FORMAT_R64G64B64A64_SFLOAT: return "VK_FORMAT_R64G64B64A64_SFLOAT";
+ case VK_FORMAT_R11G11B10_UFLOAT: return "VK_FORMAT_R11G11B10_UFLOAT";
+ case VK_FORMAT_R9G9B9E5_UFLOAT: return "VK_FORMAT_R9G9B9E5_UFLOAT";
+ case VK_FORMAT_D16_UNORM: return "VK_FORMAT_D16_UNORM";
+ case VK_FORMAT_D24_UNORM: return "VK_FORMAT_D24_UNORM";
+ case VK_FORMAT_D32_SFLOAT: return "VK_FORMAT_D32_SFLOAT";
+ case VK_FORMAT_S8_UINT: return "VK_FORMAT_S8_UINT";
+ case VK_FORMAT_D16_UNORM_S8_UINT: return "VK_FORMAT_D16_UNORM_S8_UINT";
+ case VK_FORMAT_D24_UNORM_S8_UINT: return "VK_FORMAT_D24_UNORM_S8_UINT";
+ case VK_FORMAT_D32_SFLOAT_S8_UINT: return "VK_FORMAT_D32_SFLOAT_S8_UINT";
+ case VK_FORMAT_BC1_RGB_UNORM: return "VK_FORMAT_BC1_RGB_UNORM";
+ case VK_FORMAT_BC1_RGB_SRGB: return "VK_FORMAT_BC1_RGB_SRGB";
+ case VK_FORMAT_BC1_RGBA_UNORM: return "VK_FORMAT_BC1_RGBA_UNORM";
+ case VK_FORMAT_BC1_RGBA_SRGB: return "VK_FORMAT_BC1_RGBA_SRGB";
+ case VK_FORMAT_BC2_UNORM: return "VK_FORMAT_BC2_UNORM";
+ case VK_FORMAT_BC2_SRGB: return "VK_FORMAT_BC2_SRGB";
+ case VK_FORMAT_BC3_UNORM: return "VK_FORMAT_BC3_UNORM";
+ case VK_FORMAT_BC3_SRGB: return "VK_FORMAT_BC3_SRGB";
+ case VK_FORMAT_BC4_UNORM: return "VK_FORMAT_BC4_UNORM";
+ case VK_FORMAT_BC4_SNORM: return "VK_FORMAT_BC4_SNORM";
+ case VK_FORMAT_BC5_UNORM: return "VK_FORMAT_BC5_UNORM";
+ case VK_FORMAT_BC5_SNORM: return "VK_FORMAT_BC5_SNORM";
+ case VK_FORMAT_BC6H_UFLOAT: return "VK_FORMAT_BC6H_UFLOAT";
+ case VK_FORMAT_BC6H_SFLOAT: return "VK_FORMAT_BC6H_SFLOAT";
+ case VK_FORMAT_BC7_UNORM: return "VK_FORMAT_BC7_UNORM";
+ case VK_FORMAT_BC7_SRGB: return "VK_FORMAT_BC7_SRGB";
+ case VK_FORMAT_ETC2_R8G8B8_UNORM: return "VK_FORMAT_ETC2_R8G8B8_UNORM";
+ case VK_FORMAT_ETC2_R8G8B8_SRGB: return "VK_FORMAT_ETC2_R8G8B8_SRGB";
+ case VK_FORMAT_ETC2_R8G8B8A1_UNORM: return "VK_FORMAT_ETC2_R8G8B8A1_UNORM";
+ case VK_FORMAT_ETC2_R8G8B8A1_SRGB: return "VK_FORMAT_ETC2_R8G8B8A1_SRGB";
+ case VK_FORMAT_ETC2_R8G8B8A8_UNORM: return "VK_FORMAT_ETC2_R8G8B8A8_UNORM";
+ case VK_FORMAT_ETC2_R8G8B8A8_SRGB: return "VK_FORMAT_ETC2_R8G8B8A8_SRGB";
+ case VK_FORMAT_EAC_R11_UNORM: return "VK_FORMAT_EAC_R11_UNORM";
+ case VK_FORMAT_EAC_R11_SNORM: return "VK_FORMAT_EAC_R11_SNORM";
+ case VK_FORMAT_EAC_R11G11_UNORM: return "VK_FORMAT_EAC_R11G11_UNORM";
+ case VK_FORMAT_EAC_R11G11_SNORM: return "VK_FORMAT_EAC_R11G11_SNORM";
+ case VK_FORMAT_ASTC_4x4_UNORM: return "VK_FORMAT_ASTC_4x4_UNORM";
+ case VK_FORMAT_ASTC_4x4_SRGB: return "VK_FORMAT_ASTC_4x4_SRGB";
+ case VK_FORMAT_ASTC_5x4_UNORM: return "VK_FORMAT_ASTC_5x4_UNORM";
+ case VK_FORMAT_ASTC_5x4_SRGB: return "VK_FORMAT_ASTC_5x4_SRGB";
+ case VK_FORMAT_ASTC_5x5_UNORM: return "VK_FORMAT_ASTC_5x5_UNORM";
+ case VK_FORMAT_ASTC_5x5_SRGB: return "VK_FORMAT_ASTC_5x5_SRGB";
+ case VK_FORMAT_ASTC_6x5_UNORM: return "VK_FORMAT_ASTC_6x5_UNORM";
+ case VK_FORMAT_ASTC_6x5_SRGB: return "VK_FORMAT_ASTC_6x5_SRGB";
+ case VK_FORMAT_ASTC_6x6_UNORM: return "VK_FORMAT_ASTC_6x6_UNORM";
+ case VK_FORMAT_ASTC_6x6_SRGB: return "VK_FORMAT_ASTC_6x6_SRGB";
+ case VK_FORMAT_ASTC_8x5_UNORM: return "VK_FORMAT_ASTC_8x5_UNORM";
+ case VK_FORMAT_ASTC_8x5_SRGB: return "VK_FORMAT_ASTC_8x5_SRGB";
+ case VK_FORMAT_ASTC_8x6_UNORM: return "VK_FORMAT_ASTC_8x6_UNORM";
+ case VK_FORMAT_ASTC_8x6_SRGB: return "VK_FORMAT_ASTC_8x6_SRGB";
+ case VK_FORMAT_ASTC_8x8_UNORM: return "VK_FORMAT_ASTC_8x8_UNORM";
+ case VK_FORMAT_ASTC_8x8_SRGB: return "VK_FORMAT_ASTC_8x8_SRGB";
+ case VK_FORMAT_ASTC_10x5_UNORM: return "VK_FORMAT_ASTC_10x5_UNORM";
+ case VK_FORMAT_ASTC_10x5_SRGB: return "VK_FORMAT_ASTC_10x5_SRGB";
+ case VK_FORMAT_ASTC_10x6_UNORM: return "VK_FORMAT_ASTC_10x6_UNORM";
+ case VK_FORMAT_ASTC_10x6_SRGB: return "VK_FORMAT_ASTC_10x6_SRGB";
+ case VK_FORMAT_ASTC_10x8_UNORM: return "VK_FORMAT_ASTC_10x8_UNORM";
+ case VK_FORMAT_ASTC_10x8_SRGB: return "VK_FORMAT_ASTC_10x8_SRGB";
+ case VK_FORMAT_ASTC_10x10_UNORM: return "VK_FORMAT_ASTC_10x10_UNORM";
+ case VK_FORMAT_ASTC_10x10_SRGB: return "VK_FORMAT_ASTC_10x10_SRGB";
+ case VK_FORMAT_ASTC_12x10_UNORM: return "VK_FORMAT_ASTC_12x10_UNORM";
+ case VK_FORMAT_ASTC_12x10_SRGB: return "VK_FORMAT_ASTC_12x10_SRGB";
+ case VK_FORMAT_ASTC_12x12_UNORM: return "VK_FORMAT_ASTC_12x12_UNORM";
+ case VK_FORMAT_ASTC_12x12_SRGB: return "VK_FORMAT_ASTC_12x12_SRGB";
+ case VK_FORMAT_B4G4R4A4_UNORM: return "VK_FORMAT_B4G4R4A4_UNORM";
+ case VK_FORMAT_B5G5R5A1_UNORM: return "VK_FORMAT_B5G5R5A1_UNORM";
+ case VK_FORMAT_B5G6R5_UNORM: return "VK_FORMAT_B5G6R5_UNORM";
+ case VK_FORMAT_B5G6R5_USCALED: return "VK_FORMAT_B5G6R5_USCALED";
+ case VK_FORMAT_B8G8R8_UNORM: return "VK_FORMAT_B8G8R8_UNORM";
+ case VK_FORMAT_B8G8R8_SNORM: return "VK_FORMAT_B8G8R8_SNORM";
+ case VK_FORMAT_B8G8R8_USCALED: return "VK_FORMAT_B8G8R8_USCALED";
+ case VK_FORMAT_B8G8R8_SSCALED: return "VK_FORMAT_B8G8R8_SSCALED";
+ case VK_FORMAT_B8G8R8_UINT: return "VK_FORMAT_B8G8R8_UINT";
+ case VK_FORMAT_B8G8R8_SINT: return "VK_FORMAT_B8G8R8_SINT";
+ case VK_FORMAT_B8G8R8_SRGB: return "VK_FORMAT_B8G8R8_SRGB";
+ case VK_FORMAT_B8G8R8A8_UNORM: return "VK_FORMAT_B8G8R8A8_UNORM";
+ case VK_FORMAT_B8G8R8A8_SNORM: return "VK_FORMAT_B8G8R8A8_SNORM";
+ case VK_FORMAT_B8G8R8A8_USCALED: return "VK_FORMAT_B8G8R8A8_USCALED";
+ case VK_FORMAT_B8G8R8A8_SSCALED: return "VK_FORMAT_B8G8R8A8_SSCALED";
+ case VK_FORMAT_B8G8R8A8_UINT: return "VK_FORMAT_B8G8R8A8_UINT";
+ case VK_FORMAT_B8G8R8A8_SINT: return "VK_FORMAT_B8G8R8A8_SINT";
+ case VK_FORMAT_B8G8R8A8_SRGB: return "VK_FORMAT_B8G8R8A8_SRGB";
+ case VK_FORMAT_B10G10R10A2_UNORM: return "VK_FORMAT_B10G10R10A2_UNORM";
+ case VK_FORMAT_B10G10R10A2_SNORM: return "VK_FORMAT_B10G10R10A2_SNORM";
+ case VK_FORMAT_B10G10R10A2_USCALED: return "VK_FORMAT_B10G10R10A2_USCALED";
+ case VK_FORMAT_B10G10R10A2_SSCALED: return "VK_FORMAT_B10G10R10A2_SSCALED";
+ case VK_FORMAT_B10G10R10A2_UINT: return "VK_FORMAT_B10G10R10A2_UINT";
+ case VK_FORMAT_B10G10R10A2_SINT: return "VK_FORMAT_B10G10R10A2_SINT";
default: return DE_NULL;
}
}
-const char* getAttachmentStoreOpName (VkAttachmentStoreOp value)
-{
- switch (value)
- {
- case VK_ATTACHMENT_STORE_OP_STORE: return "VK_ATTACHMENT_STORE_OP_STORE";
- case VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA: return "VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
- case VK_ATTACHMENT_STORE_OP_DONT_CARE: return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
- default: return DE_NULL;
- }
-}
-
const char* getImageTypeName (VkImageType value)
{
switch (value)
}
}
-const char* getImageViewTypeName (VkImageViewType value)
+const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value)
{
switch (value)
{
- case VK_IMAGE_VIEW_TYPE_1D: return "VK_IMAGE_VIEW_TYPE_1D";
- case VK_IMAGE_VIEW_TYPE_2D: return "VK_IMAGE_VIEW_TYPE_2D";
- case VK_IMAGE_VIEW_TYPE_3D: return "VK_IMAGE_VIEW_TYPE_3D";
- case VK_IMAGE_VIEW_TYPE_CUBE: return "VK_IMAGE_VIEW_TYPE_CUBE";
- default: return DE_NULL;
- }
-}
-
+ case VK_PHYSICAL_DEVICE_TYPE_OTHER: return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
+ case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
+ case VK_PHYSICAL_DEVICE_TYPE_CPU: return "VK_PHYSICAL_DEVICE_TYPE_CPU";
+ default: return DE_NULL;
+ }
+}
+
const char* getImageAspectName (VkImageAspect value)
{
switch (value)
case VK_IMAGE_ASPECT_COLOR: return "VK_IMAGE_ASPECT_COLOR";
case VK_IMAGE_ASPECT_DEPTH: return "VK_IMAGE_ASPECT_DEPTH";
case VK_IMAGE_ASPECT_STENCIL: return "VK_IMAGE_ASPECT_STENCIL";
+ case VK_IMAGE_ASPECT_METADATA: return "VK_IMAGE_ASPECT_METADATA";
default: return DE_NULL;
}
}
-const char* getBufferViewTypeName (VkBufferViewType value)
-{
- switch (value)
- {
- case VK_BUFFER_VIEW_TYPE_RAW: return "VK_BUFFER_VIEW_TYPE_RAW";
- case VK_BUFFER_VIEW_TYPE_FORMATTED: return "VK_BUFFER_VIEW_TYPE_FORMATTED";
- default: return DE_NULL;
- }
-}
-
-const char* getChannelSwizzleName (VkChannelSwizzle value)
-{
- switch (value)
- {
- case VK_CHANNEL_SWIZZLE_ZERO: return "VK_CHANNEL_SWIZZLE_ZERO";
- case VK_CHANNEL_SWIZZLE_ONE: return "VK_CHANNEL_SWIZZLE_ONE";
- case VK_CHANNEL_SWIZZLE_R: return "VK_CHANNEL_SWIZZLE_R";
- case VK_CHANNEL_SWIZZLE_G: return "VK_CHANNEL_SWIZZLE_G";
- case VK_CHANNEL_SWIZZLE_B: return "VK_CHANNEL_SWIZZLE_B";
- case VK_CHANNEL_SWIZZLE_A: return "VK_CHANNEL_SWIZZLE_A";
- default: return DE_NULL;
- }
-}
-
-const char* getDescriptorTypeName (VkDescriptorType value)
-{
- switch (value)
- {
- case VK_DESCRIPTOR_TYPE_SAMPLER: return "VK_DESCRIPTOR_TYPE_SAMPLER";
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
- case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
- case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
- case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
- case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
- default: return DE_NULL;
- }
-}
-
-const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value)
+const char* getQueryTypeName (VkQueryType value)
{
switch (value)
{
- case VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT: return "VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT";
- case VK_DESCRIPTOR_POOL_USAGE_DYNAMIC: return "VK_DESCRIPTOR_POOL_USAGE_DYNAMIC";
+ case VK_QUERY_TYPE_OCCLUSION: return "VK_QUERY_TYPE_OCCLUSION";
+ case VK_QUERY_TYPE_PIPELINE_STATISTICS: return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
default: return DE_NULL;
}
}
-const char* getDescriptorUpdateModeName (VkDescriptorUpdateMode value)
+const char* getSharingModeName (VkSharingMode value)
{
switch (value)
{
- case VK_DESCRIPTOR_UPDATE_MODE_COPY: return "VK_DESCRIPTOR_UPDATE_MODE_COPY";
- case VK_DESCRIPTOR_UPDATE_MODE_FASTEST: return "VK_DESCRIPTOR_UPDATE_MODE_FASTEST";
- default: return DE_NULL;
+ case VK_SHARING_MODE_EXCLUSIVE: return "VK_SHARING_MODE_EXCLUSIVE";
+ case VK_SHARING_MODE_CONCURRENT: return "VK_SHARING_MODE_CONCURRENT";
+ default: return DE_NULL;
}
}
-const char* getDescriptorSetUsageName (VkDescriptorSetUsage value)
+const char* getBufferViewTypeName (VkBufferViewType value)
{
switch (value)
{
- case VK_DESCRIPTOR_SET_USAGE_ONE_SHOT: return "VK_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case VK_DESCRIPTOR_SET_USAGE_STATIC: return "VK_DESCRIPTOR_SET_USAGE_STATIC";
- default: return DE_NULL;
+ case VK_BUFFER_VIEW_TYPE_RAW: return "VK_BUFFER_VIEW_TYPE_RAW";
+ case VK_BUFFER_VIEW_TYPE_FORMATTED: return "VK_BUFFER_VIEW_TYPE_FORMATTED";
+ default: return DE_NULL;
}
}
-const char* getQueryTypeName (VkQueryType value)
+const char* getImageViewTypeName (VkImageViewType value)
{
switch (value)
{
- case VK_QUERY_TYPE_OCCLUSION: return "VK_QUERY_TYPE_OCCLUSION";
- case VK_QUERY_TYPE_PIPELINE_STATISTICS: return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
- default: return DE_NULL;
+ case VK_IMAGE_VIEW_TYPE_1D: return "VK_IMAGE_VIEW_TYPE_1D";
+ case VK_IMAGE_VIEW_TYPE_2D: return "VK_IMAGE_VIEW_TYPE_2D";
+ case VK_IMAGE_VIEW_TYPE_3D: return "VK_IMAGE_VIEW_TYPE_3D";
+ case VK_IMAGE_VIEW_TYPE_CUBE: return "VK_IMAGE_VIEW_TYPE_CUBE";
+ case VK_IMAGE_VIEW_TYPE_1D_ARRAY: return "VK_IMAGE_VIEW_TYPE_1D_ARRAY";
+ case VK_IMAGE_VIEW_TYPE_2D_ARRAY: return "VK_IMAGE_VIEW_TYPE_2D_ARRAY";
+ case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY";
+ default: return DE_NULL;
}
}
-const char* getTimestampTypeName (VkTimestampType value)
+const char* getChannelSwizzleName (VkChannelSwizzle value)
{
switch (value)
{
- case VK_TIMESTAMP_TYPE_TOP: return "VK_TIMESTAMP_TYPE_TOP";
- case VK_TIMESTAMP_TYPE_BOTTOM: return "VK_TIMESTAMP_TYPE_BOTTOM";
+ case VK_CHANNEL_SWIZZLE_ZERO: return "VK_CHANNEL_SWIZZLE_ZERO";
+ case VK_CHANNEL_SWIZZLE_ONE: return "VK_CHANNEL_SWIZZLE_ONE";
+ case VK_CHANNEL_SWIZZLE_R: return "VK_CHANNEL_SWIZZLE_R";
+ case VK_CHANNEL_SWIZZLE_G: return "VK_CHANNEL_SWIZZLE_G";
+ case VK_CHANNEL_SWIZZLE_B: return "VK_CHANNEL_SWIZZLE_B";
+ case VK_CHANNEL_SWIZZLE_A: return "VK_CHANNEL_SWIZZLE_A";
default: return DE_NULL;
}
}
-const char* getBorderColorName (VkBorderColor value)
-{
- switch (value)
- {
- case VK_BORDER_COLOR_OPAQUE_WHITE: return "VK_BORDER_COLOR_OPAQUE_WHITE";
- case VK_BORDER_COLOR_TRANSPARENT_BLACK: return "VK_BORDER_COLOR_TRANSPARENT_BLACK";
- case VK_BORDER_COLOR_OPAQUE_BLACK: return "VK_BORDER_COLOR_OPAQUE_BLACK";
- default: return DE_NULL;
- }
-}
-
-const char* getPipelineBindPointName (VkPipelineBindPoint value)
+const char* getShaderStageName (VkShaderStage value)
{
switch (value)
{
- case VK_PIPELINE_BIND_POINT_COMPUTE: return "VK_PIPELINE_BIND_POINT_COMPUTE";
- case VK_PIPELINE_BIND_POINT_GRAPHICS: return "VK_PIPELINE_BIND_POINT_GRAPHICS";
+ case VK_SHADER_STAGE_VERTEX: return "VK_SHADER_STAGE_VERTEX";
+ case VK_SHADER_STAGE_TESS_CONTROL: return "VK_SHADER_STAGE_TESS_CONTROL";
+ case VK_SHADER_STAGE_TESS_EVALUATION: return "VK_SHADER_STAGE_TESS_EVALUATION";
+ case VK_SHADER_STAGE_GEOMETRY: return "VK_SHADER_STAGE_GEOMETRY";
+ case VK_SHADER_STAGE_FRAGMENT: return "VK_SHADER_STAGE_FRAGMENT";
+ case VK_SHADER_STAGE_COMPUTE: return "VK_SHADER_STAGE_COMPUTE";
default: return DE_NULL;
}
}
-const char* getStateBindPointName (VkStateBindPoint value)
+const char* getVertexInputStepRateName (VkVertexInputStepRate value)
{
switch (value)
{
- case VK_STATE_BIND_POINT_VIEWPORT: return "VK_STATE_BIND_POINT_VIEWPORT";
- case VK_STATE_BIND_POINT_RASTER: return "VK_STATE_BIND_POINT_RASTER";
- case VK_STATE_BIND_POINT_COLOR_BLEND: return "VK_STATE_BIND_POINT_COLOR_BLEND";
- case VK_STATE_BIND_POINT_DEPTH_STENCIL: return "VK_STATE_BIND_POINT_DEPTH_STENCIL";
- default: return DE_NULL;
+ case VK_VERTEX_INPUT_STEP_RATE_VERTEX: return "VK_VERTEX_INPUT_STEP_RATE_VERTEX";
+ case VK_VERTEX_INPUT_STEP_RATE_INSTANCE: return "VK_VERTEX_INPUT_STEP_RATE_INSTANCE";
+ default: return DE_NULL;
}
}
}
}
-const char* getIndexTypeName (VkIndexType value)
-{
- switch (value)
- {
- case VK_INDEX_TYPE_UINT8: return "VK_INDEX_TYPE_UINT8";
- case VK_INDEX_TYPE_UINT16: return "VK_INDEX_TYPE_UINT16";
- case VK_INDEX_TYPE_UINT32: return "VK_INDEX_TYPE_UINT32";
- default: return DE_NULL;
- }
-}
-
-const char* getTexFilterName (VkTexFilter value)
-{
- switch (value)
- {
- case VK_TEX_FILTER_NEAREST: return "VK_TEX_FILTER_NEAREST";
- case VK_TEX_FILTER_LINEAR: return "VK_TEX_FILTER_LINEAR";
- default: return DE_NULL;
- }
-}
-
-const char* getTexMipmapModeName (VkTexMipmapMode value)
-{
- switch (value)
- {
- case VK_TEX_MIPMAP_MODE_BASE: return "VK_TEX_MIPMAP_MODE_BASE";
- case VK_TEX_MIPMAP_MODE_NEAREST: return "VK_TEX_MIPMAP_MODE_NEAREST";
- case VK_TEX_MIPMAP_MODE_LINEAR: return "VK_TEX_MIPMAP_MODE_LINEAR";
- default: return DE_NULL;
- }
-}
-
-const char* getTexAddressName (VkTexAddress value)
-{
- switch (value)
- {
- case VK_TEX_ADDRESS_WRAP: return "VK_TEX_ADDRESS_WRAP";
- case VK_TEX_ADDRESS_MIRROR: return "VK_TEX_ADDRESS_MIRROR";
- case VK_TEX_ADDRESS_CLAMP: return "VK_TEX_ADDRESS_CLAMP";
- case VK_TEX_ADDRESS_MIRROR_ONCE: return "VK_TEX_ADDRESS_MIRROR_ONCE";
- case VK_TEX_ADDRESS_CLAMP_BORDER: return "VK_TEX_ADDRESS_CLAMP_BORDER";
- default: return DE_NULL;
- }
-}
-
-const char* getCompareOpName (VkCompareOp value)
-{
- switch (value)
- {
- case VK_COMPARE_OP_NEVER: return "VK_COMPARE_OP_NEVER";
- case VK_COMPARE_OP_LESS: return "VK_COMPARE_OP_LESS";
- case VK_COMPARE_OP_EQUAL: return "VK_COMPARE_OP_EQUAL";
- case VK_COMPARE_OP_LESS_EQUAL: return "VK_COMPARE_OP_LESS_EQUAL";
- case VK_COMPARE_OP_GREATER: return "VK_COMPARE_OP_GREATER";
- case VK_COMPARE_OP_NOT_EQUAL: return "VK_COMPARE_OP_NOT_EQUAL";
- case VK_COMPARE_OP_GREATER_EQUAL: return "VK_COMPARE_OP_GREATER_EQUAL";
- case VK_COMPARE_OP_ALWAYS: return "VK_COMPARE_OP_ALWAYS";
- default: return DE_NULL;
- }
-}
-
const char* getFillModeName (VkFillMode value)
{
switch (value)
}
}
-const char* getProvokingVertexName (VkProvokingVertex value)
+const char* getCompareOpName (VkCompareOp value)
{
switch (value)
{
- case VK_PROVOKING_VERTEX_FIRST: return "VK_PROVOKING_VERTEX_FIRST";
- case VK_PROVOKING_VERTEX_LAST: return "VK_PROVOKING_VERTEX_LAST";
- default: return DE_NULL;
+ case VK_COMPARE_OP_NEVER: return "VK_COMPARE_OP_NEVER";
+ case VK_COMPARE_OP_LESS: return "VK_COMPARE_OP_LESS";
+ case VK_COMPARE_OP_EQUAL: return "VK_COMPARE_OP_EQUAL";
+ case VK_COMPARE_OP_LESS_EQUAL: return "VK_COMPARE_OP_LESS_EQUAL";
+ case VK_COMPARE_OP_GREATER: return "VK_COMPARE_OP_GREATER";
+ case VK_COMPARE_OP_NOT_EQUAL: return "VK_COMPARE_OP_NOT_EQUAL";
+ case VK_COMPARE_OP_GREATER_EQUAL: return "VK_COMPARE_OP_GREATER_EQUAL";
+ case VK_COMPARE_OP_ALWAYS: return "VK_COMPARE_OP_ALWAYS";
+ default: return DE_NULL;
}
}
-const char* getCoordinateOriginName (VkCoordinateOrigin value)
+const char* getStencilOpName (VkStencilOp value)
{
switch (value)
{
- case VK_COORDINATE_ORIGIN_UPPER_LEFT: return "VK_COORDINATE_ORIGIN_UPPER_LEFT";
- case VK_COORDINATE_ORIGIN_LOWER_LEFT: return "VK_COORDINATE_ORIGIN_LOWER_LEFT";
- default: return DE_NULL;
+ case VK_STENCIL_OP_KEEP: return "VK_STENCIL_OP_KEEP";
+ case VK_STENCIL_OP_ZERO: return "VK_STENCIL_OP_ZERO";
+ case VK_STENCIL_OP_REPLACE: return "VK_STENCIL_OP_REPLACE";
+ case VK_STENCIL_OP_INC_CLAMP: return "VK_STENCIL_OP_INC_CLAMP";
+ case VK_STENCIL_OP_DEC_CLAMP: return "VK_STENCIL_OP_DEC_CLAMP";
+ case VK_STENCIL_OP_INVERT: return "VK_STENCIL_OP_INVERT";
+ case VK_STENCIL_OP_INC_WRAP: return "VK_STENCIL_OP_INC_WRAP";
+ case VK_STENCIL_OP_DEC_WRAP: return "VK_STENCIL_OP_DEC_WRAP";
+ default: return DE_NULL;
}
}
-const char* getDepthModeName (VkDepthMode value)
+const char* getLogicOpName (VkLogicOp value)
{
switch (value)
{
- case VK_DEPTH_MODE_ZERO_TO_ONE: return "VK_DEPTH_MODE_ZERO_TO_ONE";
- case VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE: return "VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- default: return DE_NULL;
+ case VK_LOGIC_OP_CLEAR: return "VK_LOGIC_OP_CLEAR";
+ case VK_LOGIC_OP_AND: return "VK_LOGIC_OP_AND";
+ case VK_LOGIC_OP_AND_REVERSE: return "VK_LOGIC_OP_AND_REVERSE";
+ case VK_LOGIC_OP_COPY: return "VK_LOGIC_OP_COPY";
+ case VK_LOGIC_OP_AND_INVERTED: return "VK_LOGIC_OP_AND_INVERTED";
+ case VK_LOGIC_OP_NOOP: return "VK_LOGIC_OP_NOOP";
+ case VK_LOGIC_OP_XOR: return "VK_LOGIC_OP_XOR";
+ case VK_LOGIC_OP_OR: return "VK_LOGIC_OP_OR";
+ case VK_LOGIC_OP_NOR: return "VK_LOGIC_OP_NOR";
+ case VK_LOGIC_OP_EQUIV: return "VK_LOGIC_OP_EQUIV";
+ case VK_LOGIC_OP_INVERT: return "VK_LOGIC_OP_INVERT";
+ case VK_LOGIC_OP_OR_REVERSE: return "VK_LOGIC_OP_OR_REVERSE";
+ case VK_LOGIC_OP_COPY_INVERTED: return "VK_LOGIC_OP_COPY_INVERTED";
+ case VK_LOGIC_OP_OR_INVERTED: return "VK_LOGIC_OP_OR_INVERTED";
+ case VK_LOGIC_OP_NAND: return "VK_LOGIC_OP_NAND";
+ case VK_LOGIC_OP_SET: return "VK_LOGIC_OP_SET";
+ default: return DE_NULL;
}
}
}
}
-const char* getStencilOpName (VkStencilOp value)
+const char* getTexFilterName (VkTexFilter value)
{
switch (value)
{
- case VK_STENCIL_OP_KEEP: return "VK_STENCIL_OP_KEEP";
- case VK_STENCIL_OP_ZERO: return "VK_STENCIL_OP_ZERO";
- case VK_STENCIL_OP_REPLACE: return "VK_STENCIL_OP_REPLACE";
- case VK_STENCIL_OP_INC_CLAMP: return "VK_STENCIL_OP_INC_CLAMP";
- case VK_STENCIL_OP_DEC_CLAMP: return "VK_STENCIL_OP_DEC_CLAMP";
- case VK_STENCIL_OP_INVERT: return "VK_STENCIL_OP_INVERT";
- case VK_STENCIL_OP_INC_WRAP: return "VK_STENCIL_OP_INC_WRAP";
- case VK_STENCIL_OP_DEC_WRAP: return "VK_STENCIL_OP_DEC_WRAP";
- default: return DE_NULL;
+ case VK_TEX_FILTER_NEAREST: return "VK_TEX_FILTER_NEAREST";
+ case VK_TEX_FILTER_LINEAR: return "VK_TEX_FILTER_LINEAR";
+ default: return DE_NULL;
}
}
-const char* getLogicOpName (VkLogicOp value)
+const char* getTexMipmapModeName (VkTexMipmapMode value)
{
switch (value)
{
- case VK_LOGIC_OP_COPY: return "VK_LOGIC_OP_COPY";
- case VK_LOGIC_OP_CLEAR: return "VK_LOGIC_OP_CLEAR";
- case VK_LOGIC_OP_AND: return "VK_LOGIC_OP_AND";
- case VK_LOGIC_OP_AND_REVERSE: return "VK_LOGIC_OP_AND_REVERSE";
- case VK_LOGIC_OP_AND_INVERTED: return "VK_LOGIC_OP_AND_INVERTED";
- case VK_LOGIC_OP_NOOP: return "VK_LOGIC_OP_NOOP";
- case VK_LOGIC_OP_XOR: return "VK_LOGIC_OP_XOR";
- case VK_LOGIC_OP_OR: return "VK_LOGIC_OP_OR";
- case VK_LOGIC_OP_NOR: return "VK_LOGIC_OP_NOR";
- case VK_LOGIC_OP_EQUIV: return "VK_LOGIC_OP_EQUIV";
- case VK_LOGIC_OP_INVERT: return "VK_LOGIC_OP_INVERT";
- case VK_LOGIC_OP_OR_REVERSE: return "VK_LOGIC_OP_OR_REVERSE";
- case VK_LOGIC_OP_COPY_INVERTED: return "VK_LOGIC_OP_COPY_INVERTED";
- case VK_LOGIC_OP_OR_INVERTED: return "VK_LOGIC_OP_OR_INVERTED";
- case VK_LOGIC_OP_NAND: return "VK_LOGIC_OP_NAND";
- case VK_LOGIC_OP_SET: return "VK_LOGIC_OP_SET";
- default: return DE_NULL;
+ case VK_TEX_MIPMAP_MODE_BASE: return "VK_TEX_MIPMAP_MODE_BASE";
+ case VK_TEX_MIPMAP_MODE_NEAREST: return "VK_TEX_MIPMAP_MODE_NEAREST";
+ case VK_TEX_MIPMAP_MODE_LINEAR: return "VK_TEX_MIPMAP_MODE_LINEAR";
+ default: return DE_NULL;
}
}
-const char* getSystemAllocTypeName (VkSystemAllocType value)
+const char* getTexAddressName (VkTexAddress value)
{
switch (value)
{
- case VK_SYSTEM_ALLOC_TYPE_API_OBJECT: return "VK_SYSTEM_ALLOC_TYPE_API_OBJECT";
- case VK_SYSTEM_ALLOC_TYPE_INTERNAL: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL";
- case VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP";
- case VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER: return "VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER";
- case VK_SYSTEM_ALLOC_TYPE_DEBUG: return "VK_SYSTEM_ALLOC_TYPE_DEBUG";
- default: return DE_NULL;
- }
-}
-
-const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value)
+ case VK_TEX_ADDRESS_WRAP: return "VK_TEX_ADDRESS_WRAP";
+ case VK_TEX_ADDRESS_MIRROR: return "VK_TEX_ADDRESS_MIRROR";
+ case VK_TEX_ADDRESS_CLAMP: return "VK_TEX_ADDRESS_CLAMP";
+ case VK_TEX_ADDRESS_MIRROR_ONCE: return "VK_TEX_ADDRESS_MIRROR_ONCE";
+ case VK_TEX_ADDRESS_CLAMP_BORDER: return "VK_TEX_ADDRESS_CLAMP_BORDER";
+ default: return DE_NULL;
+ }
+}
+
+const char* getBorderColorName (VkBorderColor value)
{
switch (value)
{
- case VK_PHYSICAL_DEVICE_TYPE_OTHER: return "VK_PHYSICAL_DEVICE_TYPE_OTHER";
- case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
- case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
- case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
- case VK_PHYSICAL_DEVICE_TYPE_CPU: return "VK_PHYSICAL_DEVICE_TYPE_CPU";
+ case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK";
+ case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK";
+ case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK";
+ case VK_BORDER_COLOR_INT_OPAQUE_BLACK: return "VK_BORDER_COLOR_INT_OPAQUE_BLACK";
+ case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE";
+ case VK_BORDER_COLOR_INT_OPAQUE_WHITE: return "VK_BORDER_COLOR_INT_OPAQUE_WHITE";
default: return DE_NULL;
}
}
-const char* getPhysicalDeviceInfoTypeName (VkPhysicalDeviceInfoType value)
+const char* getDescriptorTypeName (VkDescriptorType value)
{
switch (value)
{
- case VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES: return "VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES";
- case VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE: return "VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE";
- case VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES: return "VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES";
- case VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES: return "VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES";
- default: return DE_NULL;
+ case VK_DESCRIPTOR_TYPE_SAMPLER: return "VK_DESCRIPTOR_TYPE_SAMPLER";
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER";
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE";
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER";
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER";
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC";
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT";
+ default: return DE_NULL;
}
}
-const char* getExtensionInfoTypeName (VkExtensionInfoType value)
+const char* getDescriptorPoolUsageName (VkDescriptorPoolUsage value)
{
switch (value)
{
- case VK_EXTENSION_INFO_TYPE_COUNT: return "VK_EXTENSION_INFO_TYPE_COUNT";
- case VK_EXTENSION_INFO_TYPE_PROPERTIES: return "VK_EXTENSION_INFO_TYPE_PROPERTIES";
+ case VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT: return "VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT";
+ case VK_DESCRIPTOR_POOL_USAGE_DYNAMIC: return "VK_DESCRIPTOR_POOL_USAGE_DYNAMIC";
default: return DE_NULL;
}
}
-const char* getFormatInfoTypeName (VkFormatInfoType value)
+const char* getDescriptorSetUsageName (VkDescriptorSetUsage value)
{
switch (value)
{
- case VK_FORMAT_INFO_TYPE_PROPERTIES: return "VK_FORMAT_INFO_TYPE_PROPERTIES";
+ case VK_DESCRIPTOR_SET_USAGE_ONE_SHOT: return "VK_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case VK_DESCRIPTOR_SET_USAGE_STATIC: return "VK_DESCRIPTOR_SET_USAGE_STATIC";
default: return DE_NULL;
}
}
-const char* getSubresourceInfoTypeName (VkSubresourceInfoType value)
+const char* getImageLayoutName (VkImageLayout value)
{
switch (value)
{
- case VK_SUBRESOURCE_INFO_TYPE_LAYOUT: return "VK_SUBRESOURCE_INFO_TYPE_LAYOUT";
- default: return DE_NULL;
+ case VK_IMAGE_LAYOUT_UNDEFINED: return "VK_IMAGE_LAYOUT_UNDEFINED";
+ case VK_IMAGE_LAYOUT_GENERAL: return "VK_IMAGE_LAYOUT_GENERAL";
+ case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL: return "VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ default: return DE_NULL;
}
}
-const char* getObjectInfoTypeName (VkObjectInfoType value)
+const char* getAttachmentLoadOpName (VkAttachmentLoadOp value)
{
switch (value)
{
- case VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT: return "VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
- case VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS: return "VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS";
- default: return DE_NULL;
+ case VK_ATTACHMENT_LOAD_OP_LOAD: return "VK_ATTACHMENT_LOAD_OP_LOAD";
+ case VK_ATTACHMENT_LOAD_OP_CLEAR: return "VK_ATTACHMENT_LOAD_OP_CLEAR";
+ case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
+ default: return DE_NULL;
}
}
-const char* getVertexInputStepRateName (VkVertexInputStepRate value)
+const char* getAttachmentStoreOpName (VkAttachmentStoreOp value)
{
switch (value)
{
- case VK_VERTEX_INPUT_STEP_RATE_VERTEX: return "VK_VERTEX_INPUT_STEP_RATE_VERTEX";
- case VK_VERTEX_INPUT_STEP_RATE_INSTANCE: return "VK_VERTEX_INPUT_STEP_RATE_INSTANCE";
- case VK_VERTEX_INPUT_STEP_RATE_DRAW: return "VK_VERTEX_INPUT_STEP_RATE_DRAW";
- default: return DE_NULL;
+ case VK_ATTACHMENT_STORE_OP_STORE: return "VK_ATTACHMENT_STORE_OP_STORE";
+ case VK_ATTACHMENT_STORE_OP_DONT_CARE: return "VK_ATTACHMENT_STORE_OP_DONT_CARE";
+ default: return DE_NULL;
}
}
-const char* getFormatName (VkFormat value)
+const char* getPipelineBindPointName (VkPipelineBindPoint value)
{
switch (value)
{
- case VK_FORMAT_UNDEFINED: return "VK_FORMAT_UNDEFINED";
- case VK_FORMAT_R4G4_UNORM: return "VK_FORMAT_R4G4_UNORM";
- case VK_FORMAT_R4G4_USCALED: return "VK_FORMAT_R4G4_USCALED";
- case VK_FORMAT_R4G4B4A4_UNORM: return "VK_FORMAT_R4G4B4A4_UNORM";
- case VK_FORMAT_R4G4B4A4_USCALED: return "VK_FORMAT_R4G4B4A4_USCALED";
- case VK_FORMAT_R5G6B5_UNORM: return "VK_FORMAT_R5G6B5_UNORM";
- case VK_FORMAT_R5G6B5_USCALED: return "VK_FORMAT_R5G6B5_USCALED";
- case VK_FORMAT_R5G5B5A1_UNORM: return "VK_FORMAT_R5G5B5A1_UNORM";
- case VK_FORMAT_R5G5B5A1_USCALED: return "VK_FORMAT_R5G5B5A1_USCALED";
- case VK_FORMAT_R8_UNORM: return "VK_FORMAT_R8_UNORM";
- case VK_FORMAT_R8_SNORM: return "VK_FORMAT_R8_SNORM";
- case VK_FORMAT_R8_USCALED: return "VK_FORMAT_R8_USCALED";
- case VK_FORMAT_R8_SSCALED: return "VK_FORMAT_R8_SSCALED";
- case VK_FORMAT_R8_UINT: return "VK_FORMAT_R8_UINT";
- case VK_FORMAT_R8_SINT: return "VK_FORMAT_R8_SINT";
- case VK_FORMAT_R8_SRGB: return "VK_FORMAT_R8_SRGB";
- case VK_FORMAT_R8G8_UNORM: return "VK_FORMAT_R8G8_UNORM";
- case VK_FORMAT_R8G8_SNORM: return "VK_FORMAT_R8G8_SNORM";
- case VK_FORMAT_R8G8_USCALED: return "VK_FORMAT_R8G8_USCALED";
- case VK_FORMAT_R8G8_SSCALED: return "VK_FORMAT_R8G8_SSCALED";
- case VK_FORMAT_R8G8_UINT: return "VK_FORMAT_R8G8_UINT";
- case VK_FORMAT_R8G8_SINT: return "VK_FORMAT_R8G8_SINT";
- case VK_FORMAT_R8G8_SRGB: return "VK_FORMAT_R8G8_SRGB";
- case VK_FORMAT_R8G8B8_UNORM: return "VK_FORMAT_R8G8B8_UNORM";
- case VK_FORMAT_R8G8B8_SNORM: return "VK_FORMAT_R8G8B8_SNORM";
- case VK_FORMAT_R8G8B8_USCALED: return "VK_FORMAT_R8G8B8_USCALED";
- case VK_FORMAT_R8G8B8_SSCALED: return "VK_FORMAT_R8G8B8_SSCALED";
- case VK_FORMAT_R8G8B8_UINT: return "VK_FORMAT_R8G8B8_UINT";
- case VK_FORMAT_R8G8B8_SINT: return "VK_FORMAT_R8G8B8_SINT";
- case VK_FORMAT_R8G8B8_SRGB: return "VK_FORMAT_R8G8B8_SRGB";
- case VK_FORMAT_R8G8B8A8_UNORM: return "VK_FORMAT_R8G8B8A8_UNORM";
- case VK_FORMAT_R8G8B8A8_SNORM: return "VK_FORMAT_R8G8B8A8_SNORM";
- case VK_FORMAT_R8G8B8A8_USCALED: return "VK_FORMAT_R8G8B8A8_USCALED";
- case VK_FORMAT_R8G8B8A8_SSCALED: return "VK_FORMAT_R8G8B8A8_SSCALED";
- case VK_FORMAT_R8G8B8A8_UINT: return "VK_FORMAT_R8G8B8A8_UINT";
- case VK_FORMAT_R8G8B8A8_SINT: return "VK_FORMAT_R8G8B8A8_SINT";
- case VK_FORMAT_R8G8B8A8_SRGB: return "VK_FORMAT_R8G8B8A8_SRGB";
- case VK_FORMAT_R10G10B10A2_UNORM: return "VK_FORMAT_R10G10B10A2_UNORM";
- case VK_FORMAT_R10G10B10A2_SNORM: return "VK_FORMAT_R10G10B10A2_SNORM";
- case VK_FORMAT_R10G10B10A2_USCALED: return "VK_FORMAT_R10G10B10A2_USCALED";
- case VK_FORMAT_R10G10B10A2_SSCALED: return "VK_FORMAT_R10G10B10A2_SSCALED";
- case VK_FORMAT_R10G10B10A2_UINT: return "VK_FORMAT_R10G10B10A2_UINT";
- case VK_FORMAT_R10G10B10A2_SINT: return "VK_FORMAT_R10G10B10A2_SINT";
- case VK_FORMAT_R16_UNORM: return "VK_FORMAT_R16_UNORM";
- case VK_FORMAT_R16_SNORM: return "VK_FORMAT_R16_SNORM";
- case VK_FORMAT_R16_USCALED: return "VK_FORMAT_R16_USCALED";
- case VK_FORMAT_R16_SSCALED: return "VK_FORMAT_R16_SSCALED";
- case VK_FORMAT_R16_UINT: return "VK_FORMAT_R16_UINT";
- case VK_FORMAT_R16_SINT: return "VK_FORMAT_R16_SINT";
- case VK_FORMAT_R16_SFLOAT: return "VK_FORMAT_R16_SFLOAT";
- case VK_FORMAT_R16G16_UNORM: return "VK_FORMAT_R16G16_UNORM";
- case VK_FORMAT_R16G16_SNORM: return "VK_FORMAT_R16G16_SNORM";
- case VK_FORMAT_R16G16_USCALED: return "VK_FORMAT_R16G16_USCALED";
- case VK_FORMAT_R16G16_SSCALED: return "VK_FORMAT_R16G16_SSCALED";
- case VK_FORMAT_R16G16_UINT: return "VK_FORMAT_R16G16_UINT";
- case VK_FORMAT_R16G16_SINT: return "VK_FORMAT_R16G16_SINT";
- case VK_FORMAT_R16G16_SFLOAT: return "VK_FORMAT_R16G16_SFLOAT";
- case VK_FORMAT_R16G16B16_UNORM: return "VK_FORMAT_R16G16B16_UNORM";
- case VK_FORMAT_R16G16B16_SNORM: return "VK_FORMAT_R16G16B16_SNORM";
- case VK_FORMAT_R16G16B16_USCALED: return "VK_FORMAT_R16G16B16_USCALED";
- case VK_FORMAT_R16G16B16_SSCALED: return "VK_FORMAT_R16G16B16_SSCALED";
- case VK_FORMAT_R16G16B16_UINT: return "VK_FORMAT_R16G16B16_UINT";
- case VK_FORMAT_R16G16B16_SINT: return "VK_FORMAT_R16G16B16_SINT";
- case VK_FORMAT_R16G16B16_SFLOAT: return "VK_FORMAT_R16G16B16_SFLOAT";
- case VK_FORMAT_R16G16B16A16_UNORM: return "VK_FORMAT_R16G16B16A16_UNORM";
- case VK_FORMAT_R16G16B16A16_SNORM: return "VK_FORMAT_R16G16B16A16_SNORM";
- case VK_FORMAT_R16G16B16A16_USCALED: return "VK_FORMAT_R16G16B16A16_USCALED";
- case VK_FORMAT_R16G16B16A16_SSCALED: return "VK_FORMAT_R16G16B16A16_SSCALED";
- case VK_FORMAT_R16G16B16A16_UINT: return "VK_FORMAT_R16G16B16A16_UINT";
- case VK_FORMAT_R16G16B16A16_SINT: return "VK_FORMAT_R16G16B16A16_SINT";
- case VK_FORMAT_R16G16B16A16_SFLOAT: return "VK_FORMAT_R16G16B16A16_SFLOAT";
- case VK_FORMAT_R32_UINT: return "VK_FORMAT_R32_UINT";
- case VK_FORMAT_R32_SINT: return "VK_FORMAT_R32_SINT";
- case VK_FORMAT_R32_SFLOAT: return "VK_FORMAT_R32_SFLOAT";
- case VK_FORMAT_R32G32_UINT: return "VK_FORMAT_R32G32_UINT";
- case VK_FORMAT_R32G32_SINT: return "VK_FORMAT_R32G32_SINT";
- case VK_FORMAT_R32G32_SFLOAT: return "VK_FORMAT_R32G32_SFLOAT";
- case VK_FORMAT_R32G32B32_UINT: return "VK_FORMAT_R32G32B32_UINT";
- case VK_FORMAT_R32G32B32_SINT: return "VK_FORMAT_R32G32B32_SINT";
- case VK_FORMAT_R32G32B32_SFLOAT: return "VK_FORMAT_R32G32B32_SFLOAT";
- case VK_FORMAT_R32G32B32A32_UINT: return "VK_FORMAT_R32G32B32A32_UINT";
- case VK_FORMAT_R32G32B32A32_SINT: return "VK_FORMAT_R32G32B32A32_SINT";
- case VK_FORMAT_R32G32B32A32_SFLOAT: return "VK_FORMAT_R32G32B32A32_SFLOAT";
- case VK_FORMAT_R64_SFLOAT: return "VK_FORMAT_R64_SFLOAT";
- case VK_FORMAT_R64G64_SFLOAT: return "VK_FORMAT_R64G64_SFLOAT";
- case VK_FORMAT_R64G64B64_SFLOAT: return "VK_FORMAT_R64G64B64_SFLOAT";
- case VK_FORMAT_R64G64B64A64_SFLOAT: return "VK_FORMAT_R64G64B64A64_SFLOAT";
- case VK_FORMAT_R11G11B10_UFLOAT: return "VK_FORMAT_R11G11B10_UFLOAT";
- case VK_FORMAT_R9G9B9E5_UFLOAT: return "VK_FORMAT_R9G9B9E5_UFLOAT";
- case VK_FORMAT_D16_UNORM: return "VK_FORMAT_D16_UNORM";
- case VK_FORMAT_D24_UNORM: return "VK_FORMAT_D24_UNORM";
- case VK_FORMAT_D32_SFLOAT: return "VK_FORMAT_D32_SFLOAT";
- case VK_FORMAT_S8_UINT: return "VK_FORMAT_S8_UINT";
- case VK_FORMAT_D16_UNORM_S8_UINT: return "VK_FORMAT_D16_UNORM_S8_UINT";
- case VK_FORMAT_D24_UNORM_S8_UINT: return "VK_FORMAT_D24_UNORM_S8_UINT";
- case VK_FORMAT_D32_SFLOAT_S8_UINT: return "VK_FORMAT_D32_SFLOAT_S8_UINT";
- case VK_FORMAT_BC1_RGB_UNORM: return "VK_FORMAT_BC1_RGB_UNORM";
- case VK_FORMAT_BC1_RGB_SRGB: return "VK_FORMAT_BC1_RGB_SRGB";
- case VK_FORMAT_BC1_RGBA_UNORM: return "VK_FORMAT_BC1_RGBA_UNORM";
- case VK_FORMAT_BC1_RGBA_SRGB: return "VK_FORMAT_BC1_RGBA_SRGB";
- case VK_FORMAT_BC2_UNORM: return "VK_FORMAT_BC2_UNORM";
- case VK_FORMAT_BC2_SRGB: return "VK_FORMAT_BC2_SRGB";
- case VK_FORMAT_BC3_UNORM: return "VK_FORMAT_BC3_UNORM";
- case VK_FORMAT_BC3_SRGB: return "VK_FORMAT_BC3_SRGB";
- case VK_FORMAT_BC4_UNORM: return "VK_FORMAT_BC4_UNORM";
- case VK_FORMAT_BC4_SNORM: return "VK_FORMAT_BC4_SNORM";
- case VK_FORMAT_BC5_UNORM: return "VK_FORMAT_BC5_UNORM";
- case VK_FORMAT_BC5_SNORM: return "VK_FORMAT_BC5_SNORM";
- case VK_FORMAT_BC6H_UFLOAT: return "VK_FORMAT_BC6H_UFLOAT";
- case VK_FORMAT_BC6H_SFLOAT: return "VK_FORMAT_BC6H_SFLOAT";
- case VK_FORMAT_BC7_UNORM: return "VK_FORMAT_BC7_UNORM";
- case VK_FORMAT_BC7_SRGB: return "VK_FORMAT_BC7_SRGB";
- case VK_FORMAT_ETC2_R8G8B8_UNORM: return "VK_FORMAT_ETC2_R8G8B8_UNORM";
- case VK_FORMAT_ETC2_R8G8B8_SRGB: return "VK_FORMAT_ETC2_R8G8B8_SRGB";
- case VK_FORMAT_ETC2_R8G8B8A1_UNORM: return "VK_FORMAT_ETC2_R8G8B8A1_UNORM";
- case VK_FORMAT_ETC2_R8G8B8A1_SRGB: return "VK_FORMAT_ETC2_R8G8B8A1_SRGB";
- case VK_FORMAT_ETC2_R8G8B8A8_UNORM: return "VK_FORMAT_ETC2_R8G8B8A8_UNORM";
- case VK_FORMAT_ETC2_R8G8B8A8_SRGB: return "VK_FORMAT_ETC2_R8G8B8A8_SRGB";
- case VK_FORMAT_EAC_R11_UNORM: return "VK_FORMAT_EAC_R11_UNORM";
- case VK_FORMAT_EAC_R11_SNORM: return "VK_FORMAT_EAC_R11_SNORM";
- case VK_FORMAT_EAC_R11G11_UNORM: return "VK_FORMAT_EAC_R11G11_UNORM";
- case VK_FORMAT_EAC_R11G11_SNORM: return "VK_FORMAT_EAC_R11G11_SNORM";
- case VK_FORMAT_ASTC_4x4_UNORM: return "VK_FORMAT_ASTC_4x4_UNORM";
- case VK_FORMAT_ASTC_4x4_SRGB: return "VK_FORMAT_ASTC_4x4_SRGB";
- case VK_FORMAT_ASTC_5x4_UNORM: return "VK_FORMAT_ASTC_5x4_UNORM";
- case VK_FORMAT_ASTC_5x4_SRGB: return "VK_FORMAT_ASTC_5x4_SRGB";
- case VK_FORMAT_ASTC_5x5_UNORM: return "VK_FORMAT_ASTC_5x5_UNORM";
- case VK_FORMAT_ASTC_5x5_SRGB: return "VK_FORMAT_ASTC_5x5_SRGB";
- case VK_FORMAT_ASTC_6x5_UNORM: return "VK_FORMAT_ASTC_6x5_UNORM";
- case VK_FORMAT_ASTC_6x5_SRGB: return "VK_FORMAT_ASTC_6x5_SRGB";
- case VK_FORMAT_ASTC_6x6_UNORM: return "VK_FORMAT_ASTC_6x6_UNORM";
- case VK_FORMAT_ASTC_6x6_SRGB: return "VK_FORMAT_ASTC_6x6_SRGB";
- case VK_FORMAT_ASTC_8x5_UNORM: return "VK_FORMAT_ASTC_8x5_UNORM";
- case VK_FORMAT_ASTC_8x5_SRGB: return "VK_FORMAT_ASTC_8x5_SRGB";
- case VK_FORMAT_ASTC_8x6_UNORM: return "VK_FORMAT_ASTC_8x6_UNORM";
- case VK_FORMAT_ASTC_8x6_SRGB: return "VK_FORMAT_ASTC_8x6_SRGB";
- case VK_FORMAT_ASTC_8x8_UNORM: return "VK_FORMAT_ASTC_8x8_UNORM";
- case VK_FORMAT_ASTC_8x8_SRGB: return "VK_FORMAT_ASTC_8x8_SRGB";
- case VK_FORMAT_ASTC_10x5_UNORM: return "VK_FORMAT_ASTC_10x5_UNORM";
- case VK_FORMAT_ASTC_10x5_SRGB: return "VK_FORMAT_ASTC_10x5_SRGB";
- case VK_FORMAT_ASTC_10x6_UNORM: return "VK_FORMAT_ASTC_10x6_UNORM";
- case VK_FORMAT_ASTC_10x6_SRGB: return "VK_FORMAT_ASTC_10x6_SRGB";
- case VK_FORMAT_ASTC_10x8_UNORM: return "VK_FORMAT_ASTC_10x8_UNORM";
- case VK_FORMAT_ASTC_10x8_SRGB: return "VK_FORMAT_ASTC_10x8_SRGB";
- case VK_FORMAT_ASTC_10x10_UNORM: return "VK_FORMAT_ASTC_10x10_UNORM";
- case VK_FORMAT_ASTC_10x10_SRGB: return "VK_FORMAT_ASTC_10x10_SRGB";
- case VK_FORMAT_ASTC_12x10_UNORM: return "VK_FORMAT_ASTC_12x10_UNORM";
- case VK_FORMAT_ASTC_12x10_SRGB: return "VK_FORMAT_ASTC_12x10_SRGB";
- case VK_FORMAT_ASTC_12x12_UNORM: return "VK_FORMAT_ASTC_12x12_UNORM";
- case VK_FORMAT_ASTC_12x12_SRGB: return "VK_FORMAT_ASTC_12x12_SRGB";
- case VK_FORMAT_B4G4R4A4_UNORM: return "VK_FORMAT_B4G4R4A4_UNORM";
- case VK_FORMAT_B5G5R5A1_UNORM: return "VK_FORMAT_B5G5R5A1_UNORM";
- case VK_FORMAT_B5G6R5_UNORM: return "VK_FORMAT_B5G6R5_UNORM";
- case VK_FORMAT_B5G6R5_USCALED: return "VK_FORMAT_B5G6R5_USCALED";
- case VK_FORMAT_B8G8R8_UNORM: return "VK_FORMAT_B8G8R8_UNORM";
- case VK_FORMAT_B8G8R8_SNORM: return "VK_FORMAT_B8G8R8_SNORM";
- case VK_FORMAT_B8G8R8_USCALED: return "VK_FORMAT_B8G8R8_USCALED";
- case VK_FORMAT_B8G8R8_SSCALED: return "VK_FORMAT_B8G8R8_SSCALED";
- case VK_FORMAT_B8G8R8_UINT: return "VK_FORMAT_B8G8R8_UINT";
- case VK_FORMAT_B8G8R8_SINT: return "VK_FORMAT_B8G8R8_SINT";
- case VK_FORMAT_B8G8R8_SRGB: return "VK_FORMAT_B8G8R8_SRGB";
- case VK_FORMAT_B8G8R8A8_UNORM: return "VK_FORMAT_B8G8R8A8_UNORM";
- case VK_FORMAT_B8G8R8A8_SNORM: return "VK_FORMAT_B8G8R8A8_SNORM";
- case VK_FORMAT_B8G8R8A8_USCALED: return "VK_FORMAT_B8G8R8A8_USCALED";
- case VK_FORMAT_B8G8R8A8_SSCALED: return "VK_FORMAT_B8G8R8A8_SSCALED";
- case VK_FORMAT_B8G8R8A8_UINT: return "VK_FORMAT_B8G8R8A8_UINT";
- case VK_FORMAT_B8G8R8A8_SINT: return "VK_FORMAT_B8G8R8A8_SINT";
- case VK_FORMAT_B8G8R8A8_SRGB: return "VK_FORMAT_B8G8R8A8_SRGB";
- case VK_FORMAT_B10G10R10A2_UNORM: return "VK_FORMAT_B10G10R10A2_UNORM";
- case VK_FORMAT_B10G10R10A2_SNORM: return "VK_FORMAT_B10G10R10A2_SNORM";
- case VK_FORMAT_B10G10R10A2_USCALED: return "VK_FORMAT_B10G10R10A2_USCALED";
- case VK_FORMAT_B10G10R10A2_SSCALED: return "VK_FORMAT_B10G10R10A2_SSCALED";
- case VK_FORMAT_B10G10R10A2_UINT: return "VK_FORMAT_B10G10R10A2_UINT";
- case VK_FORMAT_B10G10R10A2_SINT: return "VK_FORMAT_B10G10R10A2_SINT";
+ case VK_PIPELINE_BIND_POINT_COMPUTE: return "VK_PIPELINE_BIND_POINT_COMPUTE";
+ case VK_PIPELINE_BIND_POINT_GRAPHICS: return "VK_PIPELINE_BIND_POINT_GRAPHICS";
default: return DE_NULL;
}
}
-const char* getShaderStageName (VkShaderStage value)
+const char* getCmdBufferLevelName (VkCmdBufferLevel value)
{
switch (value)
{
- case VK_SHADER_STAGE_VERTEX: return "VK_SHADER_STAGE_VERTEX";
- case VK_SHADER_STAGE_TESS_CONTROL: return "VK_SHADER_STAGE_TESS_CONTROL";
- case VK_SHADER_STAGE_TESS_EVALUATION: return "VK_SHADER_STAGE_TESS_EVALUATION";
- case VK_SHADER_STAGE_GEOMETRY: return "VK_SHADER_STAGE_GEOMETRY";
- case VK_SHADER_STAGE_FRAGMENT: return "VK_SHADER_STAGE_FRAGMENT";
- case VK_SHADER_STAGE_COMPUTE: return "VK_SHADER_STAGE_COMPUTE";
- default: return DE_NULL;
+ case VK_CMD_BUFFER_LEVEL_PRIMARY: return "VK_CMD_BUFFER_LEVEL_PRIMARY";
+ case VK_CMD_BUFFER_LEVEL_SECONDARY: return "VK_CMD_BUFFER_LEVEL_SECONDARY";
+ default: return DE_NULL;
}
}
-const char* getStructureTypeName (VkStructureType value)
+const char* getIndexTypeName (VkIndexType value)
{
switch (value)
{
- case VK_STRUCTURE_TYPE_APPLICATION_INFO: return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO: return "VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
- case VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO: return "VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
- case VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO: return "VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
- case VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO: return "VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
- case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO: return "VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO";
- case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
- case VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
- case VK_STRUCTURE_TYPE_LAYER_CREATE_INFO: return "VK_STRUCTURE_TYPE_LAYER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
- case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
- case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
- case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: return "VK_STRUCTURE_TYPE_UPDATE_SAMPLERS";
- case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: return "VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
- case VK_STRUCTURE_TYPE_UPDATE_IMAGES: return "VK_STRUCTURE_TYPE_UPDATE_IMAGES";
- case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: return "VK_STRUCTURE_TYPE_UPDATE_BUFFERS";
- case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: return "VK_STRUCTURE_TYPE_UPDATE_AS_COPY";
- case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
- default: return DE_NULL;
+ case VK_INDEX_TYPE_UINT16: return "VK_INDEX_TYPE_UINT16";
+ case VK_INDEX_TYPE_UINT32: return "VK_INDEX_TYPE_UINT32";
+ default: return DE_NULL;
}
}
-const char* getObjectTypeName (VkObjectType value)
+const char* getTimestampTypeName (VkTimestampType value)
{
switch (value)
{
- case VK_OBJECT_TYPE_INSTANCE: return "VK_OBJECT_TYPE_INSTANCE";
- case VK_OBJECT_TYPE_PHYSICAL_DEVICE: return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
- case VK_OBJECT_TYPE_DEVICE: return "VK_OBJECT_TYPE_DEVICE";
- case VK_OBJECT_TYPE_QUEUE: return "VK_OBJECT_TYPE_QUEUE";
- case VK_OBJECT_TYPE_COMMAND_BUFFER: return "VK_OBJECT_TYPE_COMMAND_BUFFER";
- case VK_OBJECT_TYPE_DEVICE_MEMORY: return "VK_OBJECT_TYPE_DEVICE_MEMORY";
- case VK_OBJECT_TYPE_BUFFER: return "VK_OBJECT_TYPE_BUFFER";
- case VK_OBJECT_TYPE_BUFFER_VIEW: return "VK_OBJECT_TYPE_BUFFER_VIEW";
- case VK_OBJECT_TYPE_IMAGE: return "VK_OBJECT_TYPE_IMAGE";
- case VK_OBJECT_TYPE_IMAGE_VIEW: return "VK_OBJECT_TYPE_IMAGE_VIEW";
- case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW: return "VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW";
- case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW: return "VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW";
- case VK_OBJECT_TYPE_SHADER: return "VK_OBJECT_TYPE_SHADER";
- case VK_OBJECT_TYPE_PIPELINE: return "VK_OBJECT_TYPE_PIPELINE";
- case VK_OBJECT_TYPE_PIPELINE_LAYOUT: return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
- case VK_OBJECT_TYPE_SAMPLER: return "VK_OBJECT_TYPE_SAMPLER";
- case VK_OBJECT_TYPE_DESCRIPTOR_SET: return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
- case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
- case VK_OBJECT_TYPE_DESCRIPTOR_POOL: return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
- case VK_OBJECT_TYPE_DYNAMIC_VP_STATE: return "VK_OBJECT_TYPE_DYNAMIC_VP_STATE";
- case VK_OBJECT_TYPE_DYNAMIC_RS_STATE: return "VK_OBJECT_TYPE_DYNAMIC_RS_STATE";
- case VK_OBJECT_TYPE_DYNAMIC_CB_STATE: return "VK_OBJECT_TYPE_DYNAMIC_CB_STATE";
- case VK_OBJECT_TYPE_DYNAMIC_DS_STATE: return "VK_OBJECT_TYPE_DYNAMIC_DS_STATE";
- case VK_OBJECT_TYPE_FENCE: return "VK_OBJECT_TYPE_FENCE";
- case VK_OBJECT_TYPE_SEMAPHORE: return "VK_OBJECT_TYPE_SEMAPHORE";
- case VK_OBJECT_TYPE_EVENT: return "VK_OBJECT_TYPE_EVENT";
- case VK_OBJECT_TYPE_QUERY_POOL: return "VK_OBJECT_TYPE_QUERY_POOL";
- case VK_OBJECT_TYPE_FRAMEBUFFER: return "VK_OBJECT_TYPE_FRAMEBUFFER";
- case VK_OBJECT_TYPE_RENDER_PASS: return "VK_OBJECT_TYPE_RENDER_PASS";
- default: return DE_NULL;
+ case VK_TIMESTAMP_TYPE_TOP: return "VK_TIMESTAMP_TYPE_TOP";
+ case VK_TIMESTAMP_TYPE_BOTTOM: return "VK_TIMESTAMP_TYPE_BOTTOM";
+ default: return DE_NULL;
}
}
-const char* getResultName (VkResult value)
+const char* getRenderPassContentsName (VkRenderPassContents value)
{
switch (value)
{
- case VK_SUCCESS: return "VK_SUCCESS";
- case VK_UNSUPPORTED: return "VK_UNSUPPORTED";
- case VK_NOT_READY: return "VK_NOT_READY";
- case VK_TIMEOUT: return "VK_TIMEOUT";
- case VK_EVENT_SET: return "VK_EVENT_SET";
- case VK_EVENT_RESET: return "VK_EVENT_RESET";
- case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN";
- case VK_ERROR_UNAVAILABLE: return "VK_ERROR_UNAVAILABLE";
- case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
- case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY";
- case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
- case VK_ERROR_DEVICE_ALREADY_CREATED: return "VK_ERROR_DEVICE_ALREADY_CREATED";
- case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
- case VK_ERROR_INVALID_POINTER: return "VK_ERROR_INVALID_POINTER";
- case VK_ERROR_INVALID_VALUE: return "VK_ERROR_INVALID_VALUE";
- case VK_ERROR_INVALID_HANDLE: return "VK_ERROR_INVALID_HANDLE";
- case VK_ERROR_INVALID_ORDINAL: return "VK_ERROR_INVALID_ORDINAL";
- case VK_ERROR_INVALID_MEMORY_SIZE: return "VK_ERROR_INVALID_MEMORY_SIZE";
- case VK_ERROR_INVALID_EXTENSION: return "VK_ERROR_INVALID_EXTENSION";
- case VK_ERROR_INVALID_FLAGS: return "VK_ERROR_INVALID_FLAGS";
- case VK_ERROR_INVALID_ALIGNMENT: return "VK_ERROR_INVALID_ALIGNMENT";
- case VK_ERROR_INVALID_FORMAT: return "VK_ERROR_INVALID_FORMAT";
- case VK_ERROR_INVALID_IMAGE: return "VK_ERROR_INVALID_IMAGE";
- case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA: return "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA";
- case VK_ERROR_INVALID_QUEUE_TYPE: return "VK_ERROR_INVALID_QUEUE_TYPE";
- case VK_ERROR_INVALID_OBJECT_TYPE: return "VK_ERROR_INVALID_OBJECT_TYPE";
- case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION: return "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
- case VK_ERROR_BAD_SHADER_CODE: return "VK_ERROR_BAD_SHADER_CODE";
- case VK_ERROR_BAD_PIPELINE_DATA: return "VK_ERROR_BAD_PIPELINE_DATA";
- case VK_ERROR_TOO_MANY_MEMORY_REFERENCES: return "VK_ERROR_TOO_MANY_MEMORY_REFERENCES";
- case VK_ERROR_NOT_MAPPABLE: return "VK_ERROR_NOT_MAPPABLE";
- case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
- case VK_ERROR_MEMORY_UNMAP_FAILED: return "VK_ERROR_MEMORY_UNMAP_FAILED";
- case VK_ERROR_INCOMPATIBLE_DEVICE: return "VK_ERROR_INCOMPATIBLE_DEVICE";
- case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
- case VK_ERROR_INCOMPLETE_COMMAND_BUFFER: return "VK_ERROR_INCOMPLETE_COMMAND_BUFFER";
- case VK_ERROR_BUILDING_COMMAND_BUFFER: return "VK_ERROR_BUILDING_COMMAND_BUFFER";
- case VK_ERROR_MEMORY_NOT_BOUND: return "VK_ERROR_MEMORY_NOT_BOUND";
- case VK_ERROR_INCOMPATIBLE_QUEUE: return "VK_ERROR_INCOMPATIBLE_QUEUE";
- case VK_ERROR_NOT_SHAREABLE: return "VK_ERROR_NOT_SHAREABLE";
- default: return DE_NULL;
+ case VK_RENDER_PASS_CONTENTS_INLINE: return "VK_RENDER_PASS_CONTENTS_INLINE";
+ case VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS: return "VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS";
+ default: return DE_NULL;
}
}
-tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value)
+tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_DEVICE_CREATE_VALIDATION_BIT, "VK_DEVICE_CREATE_VALIDATION_BIT"),
- tcu::Format::BitDesc(VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT, "VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_FORMAT_FEATURE_CONVERSION_BIT, "VK_FORMAT_FEATURE_CONVERSION_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_GENERAL, "VK_IMAGE_USAGE_GENERAL"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_SAMPLED_BIT, "VK_IMAGE_USAGE_SAMPLED_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_STORAGE_BIT, "VK_IMAGE_USAGE_STORAGE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_DEPTH_STENCIL_BIT, "VK_IMAGE_USAGE_DEPTH_STENCIL_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_QUEUE_GRAPHICS_BIT, "VK_QUEUE_GRAPHICS_BIT"),
- tcu::Format::BitDesc(VK_QUEUE_COMPUTE_BIT, "VK_QUEUE_COMPUTE_BIT"),
- tcu::Format::BitDesc(VK_QUEUE_DMA_BIT, "VK_QUEUE_DMA_BIT"),
- tcu::Format::BitDesc(VK_QUEUE_MEMMGR_BIT, "VK_QUEUE_MEMMGR_BIT"),
- tcu::Format::BitDesc(VK_QUEUE_EXTENDED_BIT, "VK_QUEUE_EXTENDED_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_GRAPHICS_BIT, "VK_QUEUE_GRAPHICS_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_COMPUTE_BIT, "VK_QUEUE_COMPUTE_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_DMA_BIT, "VK_QUEUE_DMA_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_SPARSE_MEMMGR_BIT, "VK_QUEUE_SPARSE_MEMMGR_BIT"),
+ tcu::Format::BitDesc(VK_QUEUE_EXTENDED_BIT, "VK_QUEUE_EXTENDED_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_DEVICE_ONLY, "VK_MEMORY_PROPERTY_DEVICE_ONLY"),
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT, "VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT, "VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT, "VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL, "VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL"),
- tcu::Format::BitDesc(VK_MEMORY_PROPERTY_SHAREABLE_BIT, "VK_MEMORY_PROPERTY_SHAREABLE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_DEVICE_ONLY, "VK_MEMORY_PROPERTY_DEVICE_ONLY"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT, "VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT, "VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT, "VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getMemoryHeapFlagsStr (VkMemoryHeapFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_MEMORY_HEAP_HOST_LOCAL, "VK_MEMORY_HEAP_HOST_LOCAL"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_DEVICE_CREATE_VALIDATION_BIT, "VK_DEVICE_CREATE_VALIDATION_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getSparseImageFormatFlagsStr (VkSparseImageFormatFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT, "VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT"),
+ tcu::Format::BitDesc(VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT, "VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT"),
+ tcu::Format::BitDesc(VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT, "VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getSparseMemoryBindFlagsStr (VkSparseMemoryBindFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT, "VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_FENCE_CREATE_SIGNALED_BIT, "VK_FENCE_CREATE_SIGNALED_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value)
+tcu::Format::Bitfield<32> getQueryPipelineStatisticFlagsStr (VkQueryPipelineStatisticFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_MEMORY_OUTPUT_CPU_WRITE_BIT, "VK_MEMORY_OUTPUT_CPU_WRITE_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_OUTPUT_SHADER_WRITE_BIT, "VK_MEMORY_OUTPUT_SHADER_WRITE_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT, "VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_OUTPUT_TRANSFER_BIT, "VK_MEMORY_OUTPUT_TRANSFER_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT, "VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT, "VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getMemoryInputFlagsStr (VkMemoryInputFlags value)
+tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_MEMORY_INPUT_CPU_READ_BIT, "VK_MEMORY_INPUT_CPU_READ_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT, "VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_INDEX_FETCH_BIT, "VK_MEMORY_INPUT_INDEX_FETCH_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT, "VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_UNIFORM_READ_BIT, "VK_MEMORY_INPUT_UNIFORM_READ_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_SHADER_READ_BIT, "VK_MEMORY_INPUT_SHADER_READ_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT, "VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_INPUT_TRANSFER_BIT, "VK_MEMORY_INPUT_TRANSFER_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_DEFAULT, "VK_QUERY_RESULT_DEFAULT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_64_BIT, "VK_QUERY_RESULT_64_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_WAIT_BIT, "VK_QUERY_RESULT_WAIT_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"),
+ tcu::Format::BitDesc(VK_QUERY_RESULT_PARTIAL_BIT, "VK_QUERY_RESULT_PARTIAL_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_BUFFER_CREATE_SHAREABLE_BIT, "VK_BUFFER_CREATE_SHAREABLE_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_BIT, "VK_BUFFER_CREATE_SPARSE_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_SHADER_STAGE_VERTEX_BIT, "VK_SHADER_STAGE_VERTEX_BIT"),
- tcu::Format::BitDesc(VK_SHADER_STAGE_TESS_CONTROL_BIT, "VK_SHADER_STAGE_TESS_CONTROL_BIT"),
- tcu::Format::BitDesc(VK_SHADER_STAGE_TESS_EVALUATION_BIT, "VK_SHADER_STAGE_TESS_EVALUATION_BIT"),
- tcu::Format::BitDesc(VK_SHADER_STAGE_GEOMETRY_BIT, "VK_SHADER_STAGE_GEOMETRY_BIT"),
- tcu::Format::BitDesc(VK_SHADER_STAGE_FRAGMENT_BIT, "VK_SHADER_STAGE_FRAGMENT_BIT"),
- tcu::Format::BitDesc(VK_SHADER_STAGE_COMPUTE_BIT, "VK_SHADER_STAGE_COMPUTE_BIT"),
- tcu::Format::BitDesc(VK_SHADER_STAGE_ALL, "VK_SHADER_STAGE_ALL"),
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_BIT, "VK_BUFFER_CREATE_SPARSE_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value)
+tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_IMAGE_USAGE_GENERAL, "VK_IMAGE_USAGE_GENERAL"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_SAMPLED_BIT, "VK_IMAGE_USAGE_SAMPLED_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_STORAGE_BIT, "VK_IMAGE_USAGE_STORAGE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_DEPTH_STENCIL_BIT, "VK_IMAGE_USAGE_DEPTH_STENCIL_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BIT, "VK_IMAGE_CREATE_SPARSE_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_INVARIANT_DATA_BIT, "VK_IMAGE_CREATE_INVARIANT_DATA_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value)
+tcu::Format::Bitfield<32> getAttachmentViewCreateFlagsStr (VkAttachmentViewCreateFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_IMAGE_CREATE_INVARIANT_DATA_BIT, "VK_IMAGE_CREATE_INVARIANT_DATA_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_CLONEABLE_BIT, "VK_IMAGE_CREATE_CLONEABLE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_SHAREABLE_BIT, "VK_IMAGE_CREATE_SHAREABLE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BIT, "VK_IMAGE_CREATE_SPARSE_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
- tcu::Format::BitDesc(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
+ tcu::Format::BitDesc(VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT, "VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT"),
+ tcu::Format::BitDesc(VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT, "VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getDepthStencilViewCreateFlagsStr (VkDepthStencilViewCreateFlags value)
+tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT, "VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT"),
- tcu::Format::BitDesc(VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT, "VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_R_BIT, "VK_CHANNEL_R_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_G_BIT, "VK_CHANNEL_G_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_B_BIT, "VK_CHANNEL_B_BIT"),
+ tcu::Format::BitDesc(VK_CHANNEL_A_BIT, "VK_CHANNEL_A_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
{
tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DERIVATIVE_BIT, "VK_PIPELINE_CREATE_DERIVATIVE_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getChannelFlagsStr (VkChannelFlags value)
+tcu::Format::Bitfield<32> getShaderStageFlagsStr (VkShaderStageFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_CHANNEL_R_BIT, "VK_CHANNEL_R_BIT"),
- tcu::Format::BitDesc(VK_CHANNEL_G_BIT, "VK_CHANNEL_G_BIT"),
- tcu::Format::BitDesc(VK_CHANNEL_B_BIT, "VK_CHANNEL_B_BIT"),
- tcu::Format::BitDesc(VK_CHANNEL_A_BIT, "VK_CHANNEL_A_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_VERTEX_BIT, "VK_SHADER_STAGE_VERTEX_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_TESS_CONTROL_BIT, "VK_SHADER_STAGE_TESS_CONTROL_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_TESS_EVALUATION_BIT, "VK_SHADER_STAGE_TESS_EVALUATION_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_GEOMETRY_BIT, "VK_SHADER_STAGE_GEOMETRY_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_FRAGMENT_BIT, "VK_SHADER_STAGE_FRAGMENT_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_COMPUTE_BIT, "VK_SHADER_STAGE_COMPUTE_BIT"),
+ tcu::Format::BitDesc(VK_SHADER_STAGE_ALL, "VK_SHADER_STAGE_ALL"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getFenceCreateFlagsStr (VkFenceCreateFlags value)
+tcu::Format::Bitfield<32> getSubpassDescriptionFlagsStr (VkSubpassDescriptionFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_FENCE_CREATE_SIGNALED_BIT, "VK_FENCE_CREATE_SIGNALED_BIT"),
+ tcu::Format::BitDesc(VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT, "VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getSemaphoreCreateFlagsStr (VkSemaphoreCreateFlags value)
+tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_SEMAPHORE_CREATE_SHAREABLE_BIT, "VK_SEMAPHORE_CREATE_SHAREABLE_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT, "VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT, "VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TRANSFER_BIT, "VK_PIPELINE_STAGE_TRANSFER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TRANSITION_BIT, "VK_PIPELINE_STAGE_TRANSITION_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_HOST_BIT, "VK_PIPELINE_STAGE_HOST_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GRAPHICS, "VK_PIPELINE_STAGE_ALL_GRAPHICS"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, "VK_PIPELINE_STAGE_ALL_GPU_COMMANDS"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value)
+tcu::Format::Bitfield<32> getMemoryOutputFlagsStr (VkMemoryOutputFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
- tcu::Format::BitDesc(VK_FORMAT_FEATURE_CONVERSION_BIT, "VK_FORMAT_FEATURE_CONVERSION_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_HOST_WRITE_BIT, "VK_MEMORY_OUTPUT_HOST_WRITE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_SHADER_WRITE_BIT, "VK_MEMORY_OUTPUT_SHADER_WRITE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT, "VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_OUTPUT_TRANSFER_BIT, "VK_MEMORY_OUTPUT_TRANSFER_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value)
+tcu::Format::Bitfield<32> getMemoryInputFlagsStr (VkMemoryInputFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_QUERY_CONTROL_CONSERVATIVE_BIT, "VK_QUERY_CONTROL_CONSERVATIVE_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_HOST_READ_BIT, "VK_MEMORY_INPUT_HOST_READ_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT, "VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_INDEX_FETCH_BIT, "VK_MEMORY_INPUT_INDEX_FETCH_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT, "VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_UNIFORM_READ_BIT, "VK_MEMORY_INPUT_UNIFORM_READ_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_SHADER_READ_BIT, "VK_MEMORY_INPUT_SHADER_READ_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT, "VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT, "VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_INPUT_TRANSFER_BIT, "VK_MEMORY_INPUT_TRANSFER_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getQueryResultFlagsStr (VkQueryResultFlags value)
+tcu::Format::Bitfield<32> getCmdPoolCreateFlagsStr (VkCmdPoolCreateFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_QUERY_RESULT_32_BIT, "VK_QUERY_RESULT_32_BIT"),
- tcu::Format::BitDesc(VK_QUERY_RESULT_64_BIT, "VK_QUERY_RESULT_64_BIT"),
- tcu::Format::BitDesc(VK_QUERY_RESULT_NO_WAIT_BIT, "VK_QUERY_RESULT_NO_WAIT_BIT"),
- tcu::Format::BitDesc(VK_QUERY_RESULT_WAIT_BIT, "VK_QUERY_RESULT_WAIT_BIT"),
- tcu::Format::BitDesc(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"),
- tcu::Format::BitDesc(VK_QUERY_RESULT_PARTIAL_BIT, "VK_QUERY_RESULT_PARTIAL_BIT"),
+ tcu::Format::BitDesc(VK_CMD_POOL_CREATE_TRANSIENT_BIT, "VK_CMD_POOL_CREATE_TRANSIENT_BIT"),
+ tcu::Format::BitDesc(VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, "VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getPhysicalDeviceCompatibilityFlagsStr (VkPhysicalDeviceCompatibilityFlags value)
+tcu::Format::Bitfield<32> getCmdPoolResetFlagsStr (VkCmdPoolResetFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT"),
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT"),
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT"),
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT"),
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT"),
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT"),
- tcu::Format::BitDesc(VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT, "VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT"),
+ tcu::Format::BitDesc(VK_CMD_POOL_RESET_RELEASE_RESOURCES, "VK_CMD_POOL_RESET_RELEASE_RESOURCES"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT, "VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT"),
tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT, "VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT"),
tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT, "VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT"),
+ tcu::Format::BitDesc(VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT, "VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getQueryPipelineStatisticFlagsStr (VkQueryPipelineStatisticFlags value)
+tcu::Format::Bitfield<32> getCmdBufferResetFlagsStr (VkCmdBufferResetFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT, "VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT, "VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT, "VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT"),
- tcu::Format::BitDesc(VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT, "VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT"),
+ tcu::Format::BitDesc(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES, "VK_CMD_BUFFER_RESET_RELEASE_RESOURCES"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-std::ostream& operator<< (std::ostream& s, const VkOffset2D& value)
+tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value)
{
- s << "VkOffset2D = {\n";
- s << "x = " << value.x << '\n';
- s << "y = " << value.y << '\n';
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_COLOR_BIT, "VK_IMAGE_ASPECT_COLOR_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_DEPTH_BIT, "VK_IMAGE_ASPECT_DEPTH_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_STENCIL_BIT, "VK_IMAGE_ASPECT_STENCIL_BIT"),
+ tcu::Format::BitDesc(VK_IMAGE_ASPECT_METADATA_BIT, "VK_IMAGE_ASPECT_METADATA_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getQueryControlFlagsStr (VkQueryControlFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_QUERY_CONTROL_CONSERVATIVE_BIT, "VK_QUERY_CONTROL_CONSERVATIVE_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value)
+{
+ s << "VkApplicationInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "pAppName = " << value.pAppName << '\n';
+ s << "appVersion = " << value.appVersion << '\n';
+ s << "pEngineName = " << value.pEngineName << '\n';
+ s << "engineVersion = " << value.engineVersion << '\n';
+ s << "apiVersion = " << value.apiVersion << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkOffset3D& value)
+std::ostream& operator<< (std::ostream& s, const VkAllocCallbacks& value)
{
- s << "VkOffset3D = {\n";
- s << "x = " << value.x << '\n';
- s << "y = " << value.y << '\n';
- s << "z = " << value.z << '\n';
+ s << "VkAllocCallbacks = {\n";
+ s << "pUserData = " << value.pUserData << '\n';
+ s << "pfnAlloc = " << value.pfnAlloc << '\n';
+ s << "pfnFree = " << value.pfnFree << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkExtent2D& value)
+std::ostream& operator<< (std::ostream& s, const VkInstanceCreateInfo& value)
{
- s << "VkExtent2D = {\n";
- s << "width = " << value.width << '\n';
- s << "height = " << value.height << '\n';
+ s << "VkInstanceCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "pAppInfo = " << value.pAppInfo << '\n';
+ s << "pAllocCb = " << value.pAllocCb << '\n';
+ s << "layerCount = " << value.layerCount << '\n';
+ s << "ppEnabledLayerNames = " << value.ppEnabledLayerNames << '\n';
+ s << "extensionCount = " << value.extensionCount << '\n';
+ s << "ppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkExtent3D& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceFeatures& value)
{
- s << "VkExtent3D = {\n";
- s << "width = " << value.width << '\n';
- s << "height = " << value.height << '\n';
- s << "depth = " << value.depth << '\n';
+ s << "VkPhysicalDeviceFeatures = {\n";
+ s << "robustBufferAccess = " << value.robustBufferAccess << '\n';
+ s << "fullDrawIndexUint32 = " << value.fullDrawIndexUint32 << '\n';
+ s << "imageCubeArray = " << value.imageCubeArray << '\n';
+ s << "independentBlend = " << value.independentBlend << '\n';
+ s << "geometryShader = " << value.geometryShader << '\n';
+ s << "tessellationShader = " << value.tessellationShader << '\n';
+ s << "sampleRateShading = " << value.sampleRateShading << '\n';
+ s << "dualSourceBlend = " << value.dualSourceBlend << '\n';
+ s << "logicOp = " << value.logicOp << '\n';
+ s << "instancedDrawIndirect = " << value.instancedDrawIndirect << '\n';
+ s << "depthClip = " << value.depthClip << '\n';
+ s << "depthBiasClamp = " << value.depthBiasClamp << '\n';
+ s << "fillModeNonSolid = " << value.fillModeNonSolid << '\n';
+ s << "depthBounds = " << value.depthBounds << '\n';
+ s << "wideLines = " << value.wideLines << '\n';
+ s << "largePoints = " << value.largePoints << '\n';
+ s << "textureCompressionETC2 = " << value.textureCompressionETC2 << '\n';
+ s << "textureCompressionASTC_LDR = " << value.textureCompressionASTC_LDR << '\n';
+ s << "textureCompressionBC = " << value.textureCompressionBC << '\n';
+ s << "pipelineStatisticsQuery = " << value.pipelineStatisticsQuery << '\n';
+ s << "vertexSideEffects = " << value.vertexSideEffects << '\n';
+ s << "tessellationSideEffects = " << value.tessellationSideEffects << '\n';
+ s << "geometrySideEffects = " << value.geometrySideEffects << '\n';
+ s << "fragmentSideEffects = " << value.fragmentSideEffects << '\n';
+ s << "shaderTessellationPointSize = " << value.shaderTessellationPointSize << '\n';
+ s << "shaderGeometryPointSize = " << value.shaderGeometryPointSize << '\n';
+ s << "shaderTextureGatherExtended = " << value.shaderTextureGatherExtended << '\n';
+ s << "shaderStorageImageExtendedFormats = " << value.shaderStorageImageExtendedFormats << '\n';
+ s << "shaderStorageImageMultisample = " << value.shaderStorageImageMultisample << '\n';
+ s << "shaderStorageBufferArrayConstantIndexing = " << value.shaderStorageBufferArrayConstantIndexing << '\n';
+ s << "shaderStorageImageArrayConstantIndexing = " << value.shaderStorageImageArrayConstantIndexing << '\n';
+ s << "shaderUniformBufferArrayDynamicIndexing = " << value.shaderUniformBufferArrayDynamicIndexing << '\n';
+ s << "shaderSampledImageArrayDynamicIndexing = " << value.shaderSampledImageArrayDynamicIndexing << '\n';
+ s << "shaderStorageBufferArrayDynamicIndexing = " << value.shaderStorageBufferArrayDynamicIndexing << '\n';
+ s << "shaderStorageImageArrayDynamicIndexing = " << value.shaderStorageImageArrayDynamicIndexing << '\n';
+ s << "shaderClipDistance = " << value.shaderClipDistance << '\n';
+ s << "shaderCullDistance = " << value.shaderCullDistance << '\n';
+ s << "shaderFloat64 = " << value.shaderFloat64 << '\n';
+ s << "shaderInt64 = " << value.shaderInt64 << '\n';
+ s << "shaderFloat16 = " << value.shaderFloat16 << '\n';
+ s << "shaderInt16 = " << value.shaderInt16 << '\n';
+ s << "shaderResourceResidency = " << value.shaderResourceResidency << '\n';
+ s << "shaderResourceMinLOD = " << value.shaderResourceMinLOD << '\n';
+ s << "sparse = " << value.sparse << '\n';
+ s << "sparseResidencyBuffer = " << value.sparseResidencyBuffer << '\n';
+ s << "sparseResidencyImage2D = " << value.sparseResidencyImage2D << '\n';
+ s << "sparseResidencyImage3D = " << value.sparseResidencyImage3D << '\n';
+ s << "sparseResidency2Samples = " << value.sparseResidency2Samples << '\n';
+ s << "sparseResidency4Samples = " << value.sparseResidency4Samples << '\n';
+ s << "sparseResidency8Samples = " << value.sparseResidency8Samples << '\n';
+ s << "sparseResidency16Samples = " << value.sparseResidency16Samples << '\n';
+ s << "sparseResidencyStandard2DBlockShape = " << value.sparseResidencyStandard2DBlockShape << '\n';
+ s << "sparseResidencyStandard2DMSBlockShape = " << value.sparseResidencyStandard2DMSBlockShape << '\n';
+ s << "sparseResidencyStandard3DBlockShape = " << value.sparseResidencyStandard3DBlockShape << '\n';
+ s << "sparseResidencyAlignedMipSize = " << value.sparseResidencyAlignedMipSize << '\n';
+ s << "sparseResidencyNonResident = " << value.sparseResidencyNonResident << '\n';
+ s << "sparseResidencyNonResidentStrict = " << value.sparseResidencyNonResidentStrict << '\n';
+ s << "sparseResidencyAliased = " << value.sparseResidencyAliased << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkViewport& value)
+std::ostream& operator<< (std::ostream& s, const VkFormatProperties& value)
{
- s << "VkViewport = {\n";
- s << "originX = " << value.originX << '\n';
- s << "originY = " << value.originY << '\n';
- s << "width = " << value.width << '\n';
- s << "height = " << value.height << '\n';
- s << "minDepth = " << value.minDepth << '\n';
- s << "maxDepth = " << value.maxDepth << '\n';
+ s << "VkFormatProperties = {\n";
+ s << "linearTilingFeatures = " << getFormatFeatureFlagsStr(value.linearTilingFeatures) << '\n';
+ s << "optimalTilingFeatures = " << getFormatFeatureFlagsStr(value.optimalTilingFeatures) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkRect& value)
+std::ostream& operator<< (std::ostream& s, const VkImageFormatProperties& value)
{
- s << "VkRect = {\n";
- s << "offset = " << value.offset << '\n';
- s << "extent = " << value.extent << '\n';
+ s << "VkImageFormatProperties = {\n";
+ s << "maxResourceSize = " << value.maxResourceSize << '\n';
+ s << "maxSamples = " << value.maxSamples << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkChannelMapping& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceLimits& value)
{
- s << "VkChannelMapping = {\n";
- s << "r = " << value.r << '\n';
- s << "g = " << value.g << '\n';
- s << "b = " << value.b << '\n';
- s << "a = " << value.a << '\n';
+ s << "VkPhysicalDeviceLimits = {\n";
+ s << "maxImageDimension1D = " << value.maxImageDimension1D << '\n';
+ s << "maxImageDimension2D = " << value.maxImageDimension2D << '\n';
+ s << "maxImageDimension3D = " << value.maxImageDimension3D << '\n';
+ s << "maxImageDimensionCube = " << value.maxImageDimensionCube << '\n';
+ s << "maxImageArrayLayers = " << value.maxImageArrayLayers << '\n';
+ s << "maxTexelBufferSize = " << value.maxTexelBufferSize << '\n';
+ s << "maxUniformBufferSize = " << value.maxUniformBufferSize << '\n';
+ s << "maxStorageBufferSize = " << value.maxStorageBufferSize << '\n';
+ s << "maxPushConstantsSize = " << value.maxPushConstantsSize << '\n';
+ s << "maxMemoryAllocationCount = " << value.maxMemoryAllocationCount << '\n';
+ s << "bufferImageGranularity = " << value.bufferImageGranularity << '\n';
+ s << "maxBoundDescriptorSets = " << value.maxBoundDescriptorSets << '\n';
+ s << "maxDescriptorSets = " << value.maxDescriptorSets << '\n';
+ s << "maxPerStageDescriptorSamplers = " << value.maxPerStageDescriptorSamplers << '\n';
+ s << "maxPerStageDescriptorUniformBuffers = " << value.maxPerStageDescriptorUniformBuffers << '\n';
+ s << "maxPerStageDescriptorStorageBuffers = " << value.maxPerStageDescriptorStorageBuffers << '\n';
+ s << "maxPerStageDescriptorSampledImages = " << value.maxPerStageDescriptorSampledImages << '\n';
+ s << "maxPerStageDescriptorStorageImages = " << value.maxPerStageDescriptorStorageImages << '\n';
+ s << "maxDescriptorSetSamplers = " << value.maxDescriptorSetSamplers << '\n';
+ s << "maxDescriptorSetUniformBuffers = " << value.maxDescriptorSetUniformBuffers << '\n';
+ s << "maxDescriptorSetStorageBuffers = " << value.maxDescriptorSetStorageBuffers << '\n';
+ s << "maxDescriptorSetSampledImages = " << value.maxDescriptorSetSampledImages << '\n';
+ s << "maxDescriptorSetStorageImages = " << value.maxDescriptorSetStorageImages << '\n';
+ s << "maxVertexInputAttributes = " << value.maxVertexInputAttributes << '\n';
+ s << "maxVertexInputAttributeOffset = " << value.maxVertexInputAttributeOffset << '\n';
+ s << "maxVertexInputBindingStride = " << value.maxVertexInputBindingStride << '\n';
+ s << "maxVertexOutputComponents = " << value.maxVertexOutputComponents << '\n';
+ s << "maxTessGenLevel = " << value.maxTessGenLevel << '\n';
+ s << "maxTessPatchSize = " << value.maxTessPatchSize << '\n';
+ s << "maxTessControlPerVertexInputComponents = " << value.maxTessControlPerVertexInputComponents << '\n';
+ s << "maxTessControlPerVertexOutputComponents = " << value.maxTessControlPerVertexOutputComponents << '\n';
+ s << "maxTessControlPerPatchOutputComponents = " << value.maxTessControlPerPatchOutputComponents << '\n';
+ s << "maxTessControlTotalOutputComponents = " << value.maxTessControlTotalOutputComponents << '\n';
+ s << "maxTessEvaluationInputComponents = " << value.maxTessEvaluationInputComponents << '\n';
+ s << "maxTessEvaluationOutputComponents = " << value.maxTessEvaluationOutputComponents << '\n';
+ s << "maxGeometryShaderInvocations = " << value.maxGeometryShaderInvocations << '\n';
+ s << "maxGeometryInputComponents = " << value.maxGeometryInputComponents << '\n';
+ s << "maxGeometryOutputComponents = " << value.maxGeometryOutputComponents << '\n';
+ s << "maxGeometryOutputVertices = " << value.maxGeometryOutputVertices << '\n';
+ s << "maxGeometryTotalOutputComponents = " << value.maxGeometryTotalOutputComponents << '\n';
+ s << "maxFragmentInputComponents = " << value.maxFragmentInputComponents << '\n';
+ s << "maxFragmentOutputBuffers = " << value.maxFragmentOutputBuffers << '\n';
+ s << "maxFragmentDualSourceBuffers = " << value.maxFragmentDualSourceBuffers << '\n';
+ s << "maxFragmentCombinedOutputResources = " << value.maxFragmentCombinedOutputResources << '\n';
+ s << "maxComputeSharedMemorySize = " << value.maxComputeSharedMemorySize << '\n';
+ s << "maxComputeWorkGroupCount = " << tcu::formatArray(DE_ARRAY_BEGIN(value.maxComputeWorkGroupCount), DE_ARRAY_END(value.maxComputeWorkGroupCount)) << '\n';
+ s << "maxComputeWorkGroupInvocations = " << value.maxComputeWorkGroupInvocations << '\n';
+ s << "maxComputeWorkGroupSize = " << tcu::formatArray(DE_ARRAY_BEGIN(value.maxComputeWorkGroupSize), DE_ARRAY_END(value.maxComputeWorkGroupSize)) << '\n';
+ s << "subPixelPrecisionBits = " << value.subPixelPrecisionBits << '\n';
+ s << "subTexelPrecisionBits = " << value.subTexelPrecisionBits << '\n';
+ s << "mipmapPrecisionBits = " << value.mipmapPrecisionBits << '\n';
+ s << "maxDrawIndexedIndexValue = " << value.maxDrawIndexedIndexValue << '\n';
+ s << "maxDrawIndirectInstanceCount = " << value.maxDrawIndirectInstanceCount << '\n';
+ s << "primitiveRestartForPatches = " << value.primitiveRestartForPatches << '\n';
+ s << "maxSamplerLodBias = " << value.maxSamplerLodBias << '\n';
+ s << "maxSamplerAnisotropy = " << value.maxSamplerAnisotropy << '\n';
+ s << "maxViewports = " << value.maxViewports << '\n';
+ s << "maxDynamicViewportStates = " << value.maxDynamicViewportStates << '\n';
+ s << "maxViewportDimensions = " << tcu::formatArray(DE_ARRAY_BEGIN(value.maxViewportDimensions), DE_ARRAY_END(value.maxViewportDimensions)) << '\n';
+ s << "viewportBoundsRange = " << tcu::formatArray(DE_ARRAY_BEGIN(value.viewportBoundsRange), DE_ARRAY_END(value.viewportBoundsRange)) << '\n';
+ s << "viewportSubPixelBits = " << value.viewportSubPixelBits << '\n';
+ s << "minMemoryMapAlignment = " << value.minMemoryMapAlignment << '\n';
+ s << "minTexelBufferOffsetAlignment = " << value.minTexelBufferOffsetAlignment << '\n';
+ s << "minUniformBufferOffsetAlignment = " << value.minUniformBufferOffsetAlignment << '\n';
+ s << "minStorageBufferOffsetAlignment = " << value.minStorageBufferOffsetAlignment << '\n';
+ s << "minTexelOffset = " << value.minTexelOffset << '\n';
+ s << "maxTexelOffset = " << value.maxTexelOffset << '\n';
+ s << "minTexelGatherOffset = " << value.minTexelGatherOffset << '\n';
+ s << "maxTexelGatherOffset = " << value.maxTexelGatherOffset << '\n';
+ s << "minInterpolationOffset = " << value.minInterpolationOffset << '\n';
+ s << "maxInterpolationOffset = " << value.maxInterpolationOffset << '\n';
+ s << "subPixelInterpolationOffsetBits = " << value.subPixelInterpolationOffsetBits << '\n';
+ s << "maxFramebufferWidth = " << value.maxFramebufferWidth << '\n';
+ s << "maxFramebufferHeight = " << value.maxFramebufferHeight << '\n';
+ s << "maxFramebufferLayers = " << value.maxFramebufferLayers << '\n';
+ s << "maxFramebufferColorSamples = " << value.maxFramebufferColorSamples << '\n';
+ s << "maxFramebufferDepthSamples = " << value.maxFramebufferDepthSamples << '\n';
+ s << "maxFramebufferStencilSamples = " << value.maxFramebufferStencilSamples << '\n';
+ s << "maxColorAttachments = " << value.maxColorAttachments << '\n';
+ s << "maxSampledImageColorSamples = " << value.maxSampledImageColorSamples << '\n';
+ s << "maxSampledImageDepthSamples = " << value.maxSampledImageDepthSamples << '\n';
+ s << "maxSampledImageIntegerSamples = " << value.maxSampledImageIntegerSamples << '\n';
+ s << "maxStorageImageSamples = " << value.maxStorageImageSamples << '\n';
+ s << "maxSampleMaskWords = " << value.maxSampleMaskWords << '\n';
+ s << "timestampFrequency = " << value.timestampFrequency << '\n';
+ s << "maxClipDistances = " << value.maxClipDistances << '\n';
+ s << "maxCullDistances = " << value.maxCullDistances << '\n';
+ s << "maxCombinedClipAndCullDistances = " << value.maxCombinedClipAndCullDistances << '\n';
+ s << "pointSizeRange = " << tcu::formatArray(DE_ARRAY_BEGIN(value.pointSizeRange), DE_ARRAY_END(value.pointSizeRange)) << '\n';
+ s << "lineWidthRange = " << tcu::formatArray(DE_ARRAY_BEGIN(value.lineWidthRange), DE_ARRAY_END(value.lineWidthRange)) << '\n';
+ s << "pointSizeGranularity = " << value.pointSizeGranularity << '\n';
+ s << "lineWidthGranularity = " << value.lineWidthGranularity << '\n';
s << '}';
return s;
}
s << "deviceId = " << value.deviceId << '\n';
s << "deviceType = " << value.deviceType << '\n';
s << "deviceName = " << (const char*)value.deviceName << '\n';
- s << "maxInlineMemoryUpdateSize = " << value.maxInlineMemoryUpdateSize << '\n';
- s << "maxBoundDescriptorSets = " << value.maxBoundDescriptorSets << '\n';
- s << "maxThreadGroupSize = " << value.maxThreadGroupSize << '\n';
- s << "timestampFrequency = " << value.timestampFrequency << '\n';
- s << "multiColorAttachmentClears = " << value.multiColorAttachmentClears << '\n';
- s << "maxDescriptorSets = " << value.maxDescriptorSets << '\n';
- s << "maxViewports = " << value.maxViewports << '\n';
- s << "maxColorAttachments = " << value.maxColorAttachments << '\n';
+ s << "pipelineCacheUUID = " << tcu::formatArray(DE_ARRAY_BEGIN(value.pipelineCacheUUID), DE_ARRAY_END(value.pipelineCacheUUID)) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePerformance& value)
-{
- s << "VkPhysicalDevicePerformance = {\n";
- s << "maxDeviceClock = " << value.maxDeviceClock << '\n';
- s << "aluPerClock = " << value.aluPerClock << '\n';
- s << "texPerClock = " << value.texPerClock << '\n';
- s << "primsPerClock = " << value.primsPerClock << '\n';
- s << "pixelsPerClock = " << value.pixelsPerClock << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceCompatibilityInfo& value)
-{
- s << "VkPhysicalDeviceCompatibilityInfo = {\n";
- s << "compatibilityFlags = " << getPhysicalDeviceCompatibilityFlagsStr(value.compatibilityFlags) << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkExtensionProperties& value)
-{
- s << "VkExtensionProperties = {\n";
- s << "extName = " << (const char*)value.extName << '\n';
- s << "version = " << value.version << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceQueueProperties& value)
{
- s << "VkApplicationInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "pAppName = " << value.pAppName << '\n';
- s << "appVersion = " << value.appVersion << '\n';
- s << "pEngineName = " << value.pEngineName << '\n';
- s << "engineVersion = " << value.engineVersion << '\n';
- s << "apiVersion = " << value.apiVersion << '\n';
+ s << "VkPhysicalDeviceQueueProperties = {\n";
+ s << "queueFlags = " << getQueueFlagsStr(value.queueFlags) << '\n';
+ s << "queueCount = " << value.queueCount << '\n';
+ s << "supportsTimestamps = " << value.supportsTimestamps << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkAllocCallbacks& value)
+std::ostream& operator<< (std::ostream& s, const VkMemoryType& value)
{
- s << "VkAllocCallbacks = {\n";
- s << "pUserData = " << value.pUserData << '\n';
- s << "pfnAlloc = " << value.pfnAlloc << '\n';
- s << "pfnFree = " << value.pfnFree << '\n';
+ s << "VkMemoryType = {\n";
+ s << "propertyFlags = " << getMemoryPropertyFlagsStr(value.propertyFlags) << '\n';
+ s << "heapIndex = " << value.heapIndex << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDeviceQueueCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkMemoryHeap& value)
{
- s << "VkDeviceQueueCreateInfo = {\n";
- s << "queueNodeIndex = " << value.queueNodeIndex << '\n';
- s << "queueCount = " << value.queueCount << '\n';
+ s << "VkMemoryHeap = {\n";
+ s << "size = " << value.size << '\n';
+ s << "flags = " << getMemoryHeapFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDeviceCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties& value)
{
- s << "VkDeviceCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "queueRecordCount = " << value.queueRecordCount << '\n';
- s << "pRequestedQueues = " << value.pRequestedQueues << '\n';
- s << "extensionCount = " << value.extensionCount << '\n';
- s << "ppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
- s << "flags = " << getDeviceCreateFlagsStr(value.flags) << '\n';
+ s << "VkPhysicalDeviceMemoryProperties = {\n";
+ s << "memoryTypeCount = " << value.memoryTypeCount << '\n';
+ s << "memoryTypes = " << tcu::formatArray(DE_ARRAY_BEGIN(value.memoryTypes), DE_ARRAY_END(value.memoryTypes)) << '\n';
+ s << "memoryHeapCount = " << value.memoryHeapCount << '\n';
+ s << "memoryHeaps = " << tcu::formatArray(DE_ARRAY_BEGIN(value.memoryHeaps), DE_ARRAY_END(value.memoryHeaps)) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkInstanceCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDeviceQueueCreateInfo& value)
{
- s << "VkInstanceCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "pAppInfo = " << value.pAppInfo << '\n';
- s << "pAllocCb = " << value.pAllocCb << '\n';
- s << "extensionCount = " << value.extensionCount << '\n';
- s << "ppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
+ s << "VkDeviceQueueCreateInfo = {\n";
+ s << "queueFamilyIndex = " << value.queueFamilyIndex << '\n';
+ s << "queueCount = " << value.queueCount << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkLayerCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDeviceCreateInfo& value)
{
- s << "VkLayerCreateInfo = {\n";
+ s << "VkDeviceCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
+ s << "queueRecordCount = " << value.queueRecordCount << '\n';
+ s << "pRequestedQueues = " << value.pRequestedQueues << '\n';
s << "layerCount = " << value.layerCount << '\n';
- s << "ppActiveLayerNames = " << value.ppActiveLayerNames << '\n';
+ s << "ppEnabledLayerNames = " << value.ppEnabledLayerNames << '\n';
+ s << "extensionCount = " << value.extensionCount << '\n';
+ s << "ppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
+ s << "pEnabledFeatures = " << value.pEnabledFeatures << '\n';
+ s << "flags = " << getDeviceCreateFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceQueueProperties& value)
+std::ostream& operator<< (std::ostream& s, const VkExtensionProperties& value)
{
- s << "VkPhysicalDeviceQueueProperties = {\n";
- s << "queueFlags = " << getQueueFlagsStr(value.queueFlags) << '\n';
- s << "queueCount = " << value.queueCount << '\n';
- s << "maxAtomicCounters = " << value.maxAtomicCounters << '\n';
- s << "supportsTimestamps = " << value.supportsTimestamps << '\n';
- s << "maxMemReferences = " << value.maxMemReferences << '\n';
+ s << "VkExtensionProperties = {\n";
+ s << "extName = " << (const char*)value.extName << '\n';
+ s << "specVersion = " << value.specVersion << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties& value)
+std::ostream& operator<< (std::ostream& s, const VkLayerProperties& value)
{
- s << "VkPhysicalDeviceMemoryProperties = {\n";
- s << "supportsMigration = " << value.supportsMigration << '\n';
- s << "supportsPinning = " << value.supportsPinning << '\n';
+ s << "VkLayerProperties = {\n";
+ s << "layerName = " << tcu::formatArray(DE_ARRAY_BEGIN(value.layerName), DE_ARRAY_END(value.layerName)) << '\n';
+ s << "specVersion = " << value.specVersion << '\n';
+ s << "implVersion = " << value.implVersion << '\n';
+ s << "description = " << tcu::formatArray(DE_ARRAY_BEGIN(value.description), DE_ARRAY_END(value.description)) << '\n';
s << '}';
return s;
}
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
s << "allocationSize = " << value.allocationSize << '\n';
- s << "memProps = " << getMemoryPropertyFlagsStr(value.memProps) << '\n';
- s << "memPriority = " << value.memPriority << '\n';
+ s << "memoryTypeIndex = " << value.memoryTypeIndex << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkMemoryOpenInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkMappedMemoryRange& value)
{
- s << "VkMemoryOpenInfo = {\n";
+ s << "VkMappedMemoryRange = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "sharedMem = " << value.sharedMem << '\n';
+ s << "mem = " << value.mem << '\n';
+ s << "offset = " << value.offset << '\n';
+ s << "size = " << value.size << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPeerMemoryOpenInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkMemoryRequirements& value)
{
- s << "VkPeerMemoryOpenInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "originalMem = " << value.originalMem << '\n';
+ s << "VkMemoryRequirements = {\n";
+ s << "size = " << value.size << '\n';
+ s << "alignment = " << value.alignment << '\n';
+ s << "memoryTypeBits = " << value.memoryTypeBits << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkMemoryRequirements& value)
+std::ostream& operator<< (std::ostream& s, const VkExtent3D& value)
{
- s << "VkMemoryRequirements = {\n";
- s << "size = " << value.size << '\n';
- s << "alignment = " << value.alignment << '\n';
- s << "granularity = " << value.granularity << '\n';
- s << "memPropsAllowed = " << getMemoryPropertyFlagsStr(value.memPropsAllowed) << '\n';
- s << "memPropsRequired = " << getMemoryPropertyFlagsStr(value.memPropsRequired) << '\n';
+ s << "VkExtent3D = {\n";
+ s << "width = " << value.width << '\n';
+ s << "height = " << value.height << '\n';
+ s << "depth = " << value.depth << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkFormatProperties& value)
+std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties& value)
{
- s << "VkFormatProperties = {\n";
- s << "linearTilingFeatures = " << getFormatFeatureFlagsStr(value.linearTilingFeatures) << '\n';
- s << "optimalTilingFeatures = " << getFormatFeatureFlagsStr(value.optimalTilingFeatures) << '\n';
+ s << "VkSparseImageFormatProperties = {\n";
+ s << "aspect = " << value.aspect << '\n';
+ s << "imageGranularity = " << value.imageGranularity << '\n';
+ s << "flags = " << getSparseImageFormatFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkBufferViewAttachInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryRequirements& value)
{
- s << "VkBufferViewAttachInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "view = " << value.view << '\n';
+ s << "VkSparseImageMemoryRequirements = {\n";
+ s << "formatProps = " << value.formatProps << '\n';
+ s << "imageMipTailStartLOD = " << value.imageMipTailStartLOD << '\n';
+ s << "imageMipTailSize = " << value.imageMipTailSize << '\n';
+ s << "imageMipTailOffset = " << value.imageMipTailOffset << '\n';
+ s << "imageMipTailStride = " << value.imageMipTailStride << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageViewAttachInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkSparseMemoryBindInfo& value)
{
- s << "VkImageViewAttachInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "view = " << value.view << '\n';
- s << "layout = " << value.layout << '\n';
+ s << "VkSparseMemoryBindInfo = {\n";
+ s << "offset = " << value.offset << '\n';
+ s << "memOffset = " << value.memOffset << '\n';
+ s << "mem = " << value.mem << '\n';
+ s << "flags = " << getSparseMemoryBindFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkUpdateSamplers& value)
+std::ostream& operator<< (std::ostream& s, const VkImageSubresource& value)
{
- s << "VkUpdateSamplers = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "binding = " << value.binding << '\n';
- s << "arrayIndex = " << value.arrayIndex << '\n';
- s << "count = " << value.count << '\n';
- s << "pSamplers = " << value.pSamplers << '\n';
+ s << "VkImageSubresource = {\n";
+ s << "aspect = " << value.aspect << '\n';
+ s << "mipLevel = " << value.mipLevel << '\n';
+ s << "arraySlice = " << value.arraySlice << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkSamplerImageViewInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkOffset3D& value)
{
- s << "VkSamplerImageViewInfo = {\n";
- s << "sampler = " << value.sampler << '\n';
- s << "pImageView = " << value.pImageView << '\n';
+ s << "VkOffset3D = {\n";
+ s << "x = " << value.x << '\n';
+ s << "y = " << value.y << '\n';
+ s << "z = " << value.z << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryBindInfo& value)
+{
+ s << "VkSparseImageMemoryBindInfo = {\n";
+ s << "subresource = " << value.subresource << '\n';
+ s << "offset = " << value.offset << '\n';
+ s << "extent = " << value.extent << '\n';
+ s << "memOffset = " << value.memOffset << '\n';
+ s << "mem = " << value.mem << '\n';
+ s << "flags = " << getSparseMemoryBindFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkUpdateSamplerTextures& value)
+std::ostream& operator<< (std::ostream& s, const VkFenceCreateInfo& value)
{
- s << "VkUpdateSamplerTextures = {\n";
+ s << "VkFenceCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "binding = " << value.binding << '\n';
- s << "arrayIndex = " << value.arrayIndex << '\n';
- s << "count = " << value.count << '\n';
- s << "pSamplerImageViews = " << value.pSamplerImageViews << '\n';
+ s << "flags = " << getFenceCreateFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkUpdateImages& value)
+std::ostream& operator<< (std::ostream& s, const VkSemaphoreCreateInfo& value)
{
- s << "VkUpdateImages = {\n";
+ s << "VkSemaphoreCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "descriptorType = " << value.descriptorType << '\n';
- s << "binding = " << value.binding << '\n';
- s << "arrayIndex = " << value.arrayIndex << '\n';
- s << "count = " << value.count << '\n';
- s << "pImageViews = " << value.pImageViews << '\n';
+ s << "flags = " << value.flags << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkUpdateBuffers& value)
+std::ostream& operator<< (std::ostream& s, const VkEventCreateInfo& value)
{
- s << "VkUpdateBuffers = {\n";
+ s << "VkEventCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "descriptorType = " << value.descriptorType << '\n';
- s << "binding = " << value.binding << '\n';
- s << "arrayIndex = " << value.arrayIndex << '\n';
- s << "count = " << value.count << '\n';
- s << "pBufferViews = " << value.pBufferViews << '\n';
+ s << "flags = " << value.flags << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkUpdateAsCopy& value)
+std::ostream& operator<< (std::ostream& s, const VkQueryPoolCreateInfo& value)
{
- s << "VkUpdateAsCopy = {\n";
+ s << "VkQueryPoolCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "descriptorType = " << value.descriptorType << '\n';
- s << "descriptorSet = " << value.descriptorSet << '\n';
- s << "binding = " << value.binding << '\n';
- s << "arrayElement = " << value.arrayElement << '\n';
- s << "count = " << value.count << '\n';
+ s << "queryType = " << value.queryType << '\n';
+ s << "slots = " << value.slots << '\n';
+ s << "pipelineStatistics = " << getQueryPipelineStatisticFlagsStr(value.pipelineStatistics) << '\n';
s << '}';
return s;
}
s << "size = " << value.size << '\n';
s << "usage = " << getBufferUsageFlagsStr(value.usage) << '\n';
s << "flags = " << getBufferCreateFlagsStr(value.flags) << '\n';
+ s << "sharingMode = " << value.sharingMode << '\n';
+ s << "queueFamilyCount = " << value.queueFamilyCount << '\n';
+ s << "pQueueFamilyIndices = " << value.pQueueFamilyIndices << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageSubresource& value)
+std::ostream& operator<< (std::ostream& s, const VkImageCreateInfo& value)
{
- s << "VkImageSubresource = {\n";
- s << "aspect = " << value.aspect << '\n';
- s << "mipLevel = " << value.mipLevel << '\n';
- s << "arraySlice = " << value.arraySlice << '\n';
+ s << "VkImageCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "imageType = " << value.imageType << '\n';
+ s << "format = " << value.format << '\n';
+ s << "extent = " << value.extent << '\n';
+ s << "mipLevels = " << value.mipLevels << '\n';
+ s << "arraySize = " << value.arraySize << '\n';
+ s << "samples = " << value.samples << '\n';
+ s << "tiling = " << value.tiling << '\n';
+ s << "usage = " << getImageUsageFlagsStr(value.usage) << '\n';
+ s << "flags = " << getImageCreateFlagsStr(value.flags) << '\n';
+ s << "sharingMode = " << value.sharingMode << '\n';
+ s << "queueFamilyCount = " << value.queueFamilyCount << '\n';
+ s << "pQueueFamilyIndices = " << value.pQueueFamilyIndices << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSubresourceLayout& value)
+{
+ s << "VkSubresourceLayout = {\n";
+ s << "offset = " << value.offset << '\n';
+ s << "size = " << value.size << '\n';
+ s << "rowPitch = " << value.rowPitch << '\n';
+ s << "depthPitch = " << value.depthPitch << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkChannelMapping& value)
+{
+ s << "VkChannelMapping = {\n";
+ s << "r = " << value.r << '\n';
+ s << "g = " << value.g << '\n';
+ s << "b = " << value.b << '\n';
+ s << "a = " << value.a << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value)
+std::ostream& operator<< (std::ostream& s, const VkImageViewCreateInfo& value)
{
- s << "VkMemoryBarrier = {\n";
+ s << "VkImageViewCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
- s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
+ s << "image = " << value.image << '\n';
+ s << "viewType = " << value.viewType << '\n';
+ s << "format = " << value.format << '\n';
+ s << "channels = " << value.channels << '\n';
+ s << "subresourceRange = " << value.subresourceRange << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkBufferMemoryBarrier& value)
+std::ostream& operator<< (std::ostream& s, const VkAttachmentViewCreateInfo& value)
{
- s << "VkBufferMemoryBarrier = {\n";
+ s << "VkAttachmentViewCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
- s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
- s << "buffer = " << value.buffer << '\n';
- s << "offset = " << value.offset << '\n';
+ s << "image = " << value.image << '\n';
+ s << "format = " << value.format << '\n';
+ s << "mipLevel = " << value.mipLevel << '\n';
+ s << "baseArraySlice = " << value.baseArraySlice << '\n';
+ s << "arraySize = " << value.arraySize << '\n';
+ s << "flags = " << getAttachmentViewCreateFlagsStr(value.flags) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkShaderModuleCreateInfo& value)
+{
+ s << "VkShaderModuleCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "codeSize = " << value.codeSize << '\n';
+ s << "pCode = " << value.pCode << '\n';
+ s << "flags = " << value.flags << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkShaderCreateInfo& value)
+{
+ s << "VkShaderCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "module = " << value.module << '\n';
+ s << "pName = " << value.pName << '\n';
+ s << "flags = " << value.flags << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineCacheCreateInfo& value)
+{
+ s << "VkPipelineCacheCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "initialSize = " << value.initialSize << '\n';
+ s << "initialData = " << value.initialData << '\n';
+ s << "maxSize = " << value.maxSize << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSpecializationMapEntry& value)
+{
+ s << "VkSpecializationMapEntry = {\n";
+ s << "constantId = " << value.constantId << '\n';
s << "size = " << value.size << '\n';
+ s << "offset = " << value.offset << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSpecializationInfo& value)
+{
+ s << "VkSpecializationInfo = {\n";
+ s << "mapEntryCount = " << value.mapEntryCount << '\n';
+ s << "pMap = " << value.pMap << '\n';
+ s << "dataSize = " << value.dataSize << '\n';
+ s << "pData = " << value.pData << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPipelineShaderStageCreateInfo& value)
+{
+ s << "VkPipelineShaderStageCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "stage = " << value.stage << '\n';
+ s << "shader = " << value.shader << '\n';
+ s << "pSpecializationInfo = " << value.pSpecializationInfo << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkVertexInputBindingDescription& value)
+{
+ s << "VkVertexInputBindingDescription = {\n";
+ s << "binding = " << value.binding << '\n';
+ s << "strideInBytes = " << value.strideInBytes << '\n';
+ s << "stepRate = " << value.stepRate << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value)
+std::ostream& operator<< (std::ostream& s, const VkVertexInputAttributeDescription& value)
{
- s << "VkImageMemoryBarrier = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
- s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
- s << "oldLayout = " << value.oldLayout << '\n';
- s << "newLayout = " << value.newLayout << '\n';
- s << "image = " << value.image << '\n';
- s << "subresourceRange = " << value.subresourceRange << '\n';
+ s << "VkVertexInputAttributeDescription = {\n";
+ s << "location = " << value.location << '\n';
+ s << "binding = " << value.binding << '\n';
+ s << "format = " << value.format << '\n';
+ s << "offsetInBytes = " << value.offsetInBytes << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineVertexInputStateCreateInfo& value)
{
- s << "VkImageCreateInfo = {\n";
+ s << "VkPipelineVertexInputStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "imageType = " << value.imageType << '\n';
- s << "format = " << value.format << '\n';
- s << "extent = " << value.extent << '\n';
- s << "mipLevels = " << value.mipLevels << '\n';
- s << "arraySize = " << value.arraySize << '\n';
- s << "samples = " << value.samples << '\n';
- s << "tiling = " << value.tiling << '\n';
- s << "usage = " << getImageUsageFlagsStr(value.usage) << '\n';
- s << "flags = " << getImageCreateFlagsStr(value.flags) << '\n';
+ s << "bindingCount = " << value.bindingCount << '\n';
+ s << "pVertexBindingDescriptions = " << value.pVertexBindingDescriptions << '\n';
+ s << "attributeCount = " << value.attributeCount << '\n';
+ s << "pVertexAttributeDescriptions = " << value.pVertexAttributeDescriptions << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPeerImageOpenInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineInputAssemblyStateCreateInfo& value)
{
- s << "VkPeerImageOpenInfo = {\n";
- s << "originalImage = " << value.originalImage << '\n';
+ s << "VkPipelineInputAssemblyStateCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "topology = " << value.topology << '\n';
+ s << "primitiveRestartEnable = " << value.primitiveRestartEnable << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkSubresourceLayout& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineTessellationStateCreateInfo& value)
{
- s << "VkSubresourceLayout = {\n";
- s << "offset = " << value.offset << '\n';
- s << "size = " << value.size << '\n';
- s << "rowPitch = " << value.rowPitch << '\n';
- s << "depthPitch = " << value.depthPitch << '\n';
+ s << "VkPipelineTessellationStateCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "patchControlPoints = " << value.patchControlPoints << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageViewCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineViewportStateCreateInfo& value)
{
- s << "VkImageViewCreateInfo = {\n";
+ s << "VkPipelineViewportStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "image = " << value.image << '\n';
- s << "viewType = " << value.viewType << '\n';
- s << "format = " << value.format << '\n';
- s << "channels = " << value.channels << '\n';
- s << "subresourceRange = " << value.subresourceRange << '\n';
- s << "minLod = " << value.minLod << '\n';
+ s << "viewportCount = " << value.viewportCount << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkColorAttachmentViewCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineRasterStateCreateInfo& value)
{
- s << "VkColorAttachmentViewCreateInfo = {\n";
+ s << "VkPipelineRasterStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "image = " << value.image << '\n';
- s << "format = " << value.format << '\n';
- s << "mipLevel = " << value.mipLevel << '\n';
- s << "baseArraySlice = " << value.baseArraySlice << '\n';
- s << "arraySize = " << value.arraySize << '\n';
- s << "msaaResolveImage = " << value.msaaResolveImage << '\n';
- s << "msaaResolveSubResource = " << value.msaaResolveSubResource << '\n';
+ s << "depthClipEnable = " << value.depthClipEnable << '\n';
+ s << "rasterizerDiscardEnable = " << value.rasterizerDiscardEnable << '\n';
+ s << "fillMode = " << value.fillMode << '\n';
+ s << "cullMode = " << value.cullMode << '\n';
+ s << "frontFace = " << value.frontFace << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDepthStencilViewCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineMultisampleStateCreateInfo& value)
{
- s << "VkDepthStencilViewCreateInfo = {\n";
+ s << "VkPipelineMultisampleStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "image = " << value.image << '\n';
- s << "mipLevel = " << value.mipLevel << '\n';
- s << "baseArraySlice = " << value.baseArraySlice << '\n';
- s << "arraySize = " << value.arraySize << '\n';
- s << "msaaResolveImage = " << value.msaaResolveImage << '\n';
- s << "msaaResolveSubResource = " << value.msaaResolveSubResource << '\n';
- s << "flags = " << getDepthStencilViewCreateFlagsStr(value.flags) << '\n';
+ s << "rasterSamples = " << value.rasterSamples << '\n';
+ s << "sampleShadingEnable = " << value.sampleShadingEnable << '\n';
+ s << "minSampleShading = " << value.minSampleShading << '\n';
+ s << "sampleMask = " << value.sampleMask << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkColorAttachmentBindInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkStencilOpState& value)
{
- s << "VkColorAttachmentBindInfo = {\n";
- s << "view = " << value.view << '\n';
- s << "layout = " << value.layout << '\n';
+ s << "VkStencilOpState = {\n";
+ s << "stencilFailOp = " << value.stencilFailOp << '\n';
+ s << "stencilPassOp = " << value.stencilPassOp << '\n';
+ s << "stencilDepthFailOp = " << value.stencilDepthFailOp << '\n';
+ s << "stencilCompareOp = " << value.stencilCompareOp << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDepthStencilBindInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineDepthStencilStateCreateInfo& value)
{
- s << "VkDepthStencilBindInfo = {\n";
- s << "view = " << value.view << '\n';
- s << "layout = " << value.layout << '\n';
+ s << "VkPipelineDepthStencilStateCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "depthTestEnable = " << value.depthTestEnable << '\n';
+ s << "depthWriteEnable = " << value.depthWriteEnable << '\n';
+ s << "depthCompareOp = " << value.depthCompareOp << '\n';
+ s << "depthBoundsEnable = " << value.depthBoundsEnable << '\n';
+ s << "stencilTestEnable = " << value.stencilTestEnable << '\n';
+ s << "front = " << value.front << '\n';
+ s << "back = " << value.back << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendAttachmentState& value)
{
- s << "VkBufferCopy = {\n";
- s << "srcOffset = " << value.srcOffset << '\n';
- s << "destOffset = " << value.destOffset << '\n';
- s << "copySize = " << value.copySize << '\n';
+ s << "VkPipelineColorBlendAttachmentState = {\n";
+ s << "blendEnable = " << value.blendEnable << '\n';
+ s << "srcBlendColor = " << value.srcBlendColor << '\n';
+ s << "destBlendColor = " << value.destBlendColor << '\n';
+ s << "blendOpColor = " << value.blendOpColor << '\n';
+ s << "srcBlendAlpha = " << value.srcBlendAlpha << '\n';
+ s << "destBlendAlpha = " << value.destBlendAlpha << '\n';
+ s << "blendOpAlpha = " << value.blendOpAlpha << '\n';
+ s << "channelWriteMask = " << getChannelFlagsStr(value.channelWriteMask) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageMemoryBindInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendStateCreateInfo& value)
{
- s << "VkImageMemoryBindInfo = {\n";
- s << "subresource = " << value.subresource << '\n';
- s << "offset = " << value.offset << '\n';
- s << "extent = " << value.extent << '\n';
+ s << "VkPipelineColorBlendStateCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "alphaToCoverageEnable = " << value.alphaToCoverageEnable << '\n';
+ s << "logicOpEnable = " << value.logicOpEnable << '\n';
+ s << "logicOp = " << value.logicOp << '\n';
+ s << "attachmentCount = " << value.attachmentCount << '\n';
+ s << "pAttachments = " << value.pAttachments << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageCopy& value)
+std::ostream& operator<< (std::ostream& s, const VkGraphicsPipelineCreateInfo& value)
{
- s << "VkImageCopy = {\n";
- s << "srcSubresource = " << value.srcSubresource << '\n';
- s << "srcOffset = " << value.srcOffset << '\n';
- s << "destSubresource = " << value.destSubresource << '\n';
- s << "destOffset = " << value.destOffset << '\n';
- s << "extent = " << value.extent << '\n';
+ s << "VkGraphicsPipelineCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "stageCount = " << value.stageCount << '\n';
+ s << "pStages = " << value.pStages << '\n';
+ s << "pVertexInputState = " << value.pVertexInputState << '\n';
+ s << "pInputAssemblyState = " << value.pInputAssemblyState << '\n';
+ s << "pTessellationState = " << value.pTessellationState << '\n';
+ s << "pViewportState = " << value.pViewportState << '\n';
+ s << "pRasterState = " << value.pRasterState << '\n';
+ s << "pMultisampleState = " << value.pMultisampleState << '\n';
+ s << "pDepthStencilState = " << value.pDepthStencilState << '\n';
+ s << "pColorBlendState = " << value.pColorBlendState << '\n';
+ s << "flags = " << getPipelineCreateFlagsStr(value.flags) << '\n';
+ s << "layout = " << value.layout << '\n';
+ s << "renderPass = " << value.renderPass << '\n';
+ s << "subpass = " << value.subpass << '\n';
+ s << "basePipelineHandle = " << value.basePipelineHandle << '\n';
+ s << "basePipelineIndex = " << value.basePipelineIndex << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageBlit& value)
+std::ostream& operator<< (std::ostream& s, const VkComputePipelineCreateInfo& value)
{
- s << "VkImageBlit = {\n";
- s << "srcSubresource = " << value.srcSubresource << '\n';
- s << "srcOffset = " << value.srcOffset << '\n';
- s << "srcExtent = " << value.srcExtent << '\n';
- s << "destSubresource = " << value.destSubresource << '\n';
- s << "destOffset = " << value.destOffset << '\n';
- s << "destExtent = " << value.destExtent << '\n';
+ s << "VkComputePipelineCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "cs = " << value.cs << '\n';
+ s << "flags = " << getPipelineCreateFlagsStr(value.flags) << '\n';
+ s << "layout = " << value.layout << '\n';
+ s << "basePipelineHandle = " << value.basePipelineHandle << '\n';
+ s << "basePipelineIndex = " << value.basePipelineIndex << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkBufferImageCopy& value)
+std::ostream& operator<< (std::ostream& s, const VkPushConstantRange& value)
{
- s << "VkBufferImageCopy = {\n";
- s << "bufferOffset = " << value.bufferOffset << '\n';
- s << "imageSubresource = " << value.imageSubresource << '\n';
- s << "imageOffset = " << value.imageOffset << '\n';
- s << "imageExtent = " << value.imageExtent << '\n';
+ s << "VkPushConstantRange = {\n";
+ s << "stageFlags = " << getShaderStageFlagsStr(value.stageFlags) << '\n';
+ s << "start = " << value.start << '\n';
+ s << "length = " << value.length << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkImageResolve& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineLayoutCreateInfo& value)
{
- s << "VkImageResolve = {\n";
- s << "srcSubresource = " << value.srcSubresource << '\n';
- s << "srcOffset = " << value.srcOffset << '\n';
- s << "destSubresource = " << value.destSubresource << '\n';
- s << "destOffset = " << value.destOffset << '\n';
- s << "extent = " << value.extent << '\n';
+ s << "VkPipelineLayoutCreateInfo = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "descriptorSetCount = " << value.descriptorSetCount << '\n';
+ s << "pSetLayouts = " << value.pSetLayouts << '\n';
+ s << "pushConstantRangeCount = " << value.pushConstantRangeCount << '\n';
+ s << "pPushConstantRanges = " << value.pPushConstantRanges << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkShaderCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkSamplerCreateInfo& value)
{
- s << "VkShaderCreateInfo = {\n";
+ s << "VkSamplerCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "codeSize = " << value.codeSize << '\n';
- s << "pCode = " << value.pCode << '\n';
- s << "flags = " << value.flags << '\n';
+ s << "magFilter = " << value.magFilter << '\n';
+ s << "minFilter = " << value.minFilter << '\n';
+ s << "mipMode = " << value.mipMode << '\n';
+ s << "addressU = " << value.addressU << '\n';
+ s << "addressV = " << value.addressV << '\n';
+ s << "addressW = " << value.addressW << '\n';
+ s << "mipLodBias = " << value.mipLodBias << '\n';
+ s << "maxAnisotropy = " << value.maxAnisotropy << '\n';
+ s << "compareEnable = " << value.compareEnable << '\n';
+ s << "compareOp = " << value.compareOp << '\n';
+ s << "minLod = " << value.minLod << '\n';
+ s << "maxLod = " << value.maxLod << '\n';
+ s << "borderColor = " << value.borderColor << '\n';
s << '}';
return s;
}
{
s << "VkDescriptorSetLayoutBinding = {\n";
s << "descriptorType = " << value.descriptorType << '\n';
- s << "count = " << value.count << '\n';
+ s << "arraySize = " << value.arraySize << '\n';
s << "stageFlags = " << getShaderStageFlagsStr(value.stageFlags) << '\n';
s << "pImmutableSamplers = " << value.pImmutableSamplers << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkLinkConstBuffer& value)
-{
- s << "VkLinkConstBuffer = {\n";
- s << "bufferId = " << value.bufferId << '\n';
- s << "bufferSize = " << value.bufferSize << '\n';
- s << "pBufferData = " << value.pBufferData << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkSpecializationMapEntry& value)
-{
- s << "VkSpecializationMapEntry = {\n";
- s << "constantId = " << value.constantId << '\n';
- s << "offset = " << value.offset << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkSpecializationInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDescriptorInfo& value)
{
- s << "VkSpecializationInfo = {\n";
- s << "mapEntryCount = " << value.mapEntryCount << '\n';
- s << "pMap = " << value.pMap << '\n';
- s << "pData = " << value.pData << '\n';
+ s << "VkDescriptorInfo = {\n";
+ s << "bufferView = " << value.bufferView << '\n';
+ s << "sampler = " << value.sampler << '\n';
+ s << "imageView = " << value.imageView << '\n';
+ s << "attachmentView = " << value.attachmentView << '\n';
+ s << "imageLayout = " << value.imageLayout << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineShader& value)
+std::ostream& operator<< (std::ostream& s, const VkWriteDescriptorSet& value)
{
- s << "VkPipelineShader = {\n";
- s << "stage = " << value.stage << '\n';
- s << "shader = " << value.shader << '\n';
- s << "linkConstBufferCount = " << value.linkConstBufferCount << '\n';
- s << "pLinkConstBufferInfo = " << value.pLinkConstBufferInfo << '\n';
- s << "pSpecializationInfo = " << value.pSpecializationInfo << '\n';
+ s << "VkWriteDescriptorSet = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "destSet = " << value.destSet << '\n';
+ s << "destBinding = " << value.destBinding << '\n';
+ s << "destArrayElement = " << value.destArrayElement << '\n';
+ s << "count = " << value.count << '\n';
+ s << "descriptorType = " << value.descriptorType << '\n';
+ s << "pDescriptors = " << value.pDescriptors << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkComputePipelineCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkCopyDescriptorSet& value)
{
- s << "VkComputePipelineCreateInfo = {\n";
+ s << "VkCopyDescriptorSet = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "cs = " << value.cs << '\n';
- s << "flags = " << getPipelineCreateFlagsStr(value.flags) << '\n';
- s << "layout = " << value.layout << '\n';
+ s << "srcSet = " << value.srcSet << '\n';
+ s << "srcBinding = " << value.srcBinding << '\n';
+ s << "srcArrayElement = " << value.srcArrayElement << '\n';
+ s << "destSet = " << value.destSet << '\n';
+ s << "destBinding = " << value.destBinding << '\n';
+ s << "destArrayElement = " << value.destArrayElement << '\n';
+ s << "count = " << value.count << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkVertexInputBindingDescription& value)
+std::ostream& operator<< (std::ostream& s, const VkViewport& value)
{
- s << "VkVertexInputBindingDescription = {\n";
- s << "binding = " << value.binding << '\n';
- s << "strideInBytes = " << value.strideInBytes << '\n';
- s << "stepRate = " << value.stepRate << '\n';
+ s << "VkViewport = {\n";
+ s << "originX = " << value.originX << '\n';
+ s << "originY = " << value.originY << '\n';
+ s << "width = " << value.width << '\n';
+ s << "height = " << value.height << '\n';
+ s << "minDepth = " << value.minDepth << '\n';
+ s << "maxDepth = " << value.maxDepth << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkVertexInputAttributeDescription& value)
+std::ostream& operator<< (std::ostream& s, const VkOffset2D& value)
{
- s << "VkVertexInputAttributeDescription = {\n";
- s << "location = " << value.location << '\n';
- s << "binding = " << value.binding << '\n';
- s << "format = " << value.format << '\n';
- s << "offsetInBytes = " << value.offsetInBytes << '\n';
+ s << "VkOffset2D = {\n";
+ s << "x = " << value.x << '\n';
+ s << "y = " << value.y << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineVertexInputCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkExtent2D& value)
{
- s << "VkPipelineVertexInputCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "bindingCount = " << value.bindingCount << '\n';
- s << "pVertexBindingDescriptions = " << value.pVertexBindingDescriptions << '\n';
- s << "attributeCount = " << value.attributeCount << '\n';
- s << "pVertexAttributeDescriptions = " << value.pVertexAttributeDescriptions << '\n';
+ s << "VkExtent2D = {\n";
+ s << "width = " << value.width << '\n';
+ s << "height = " << value.height << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineIaStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkRect2D& value)
{
- s << "VkPipelineIaStateCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "topology = " << value.topology << '\n';
- s << "disableVertexReuse = " << value.disableVertexReuse << '\n';
- s << "primitiveRestartEnable = " << value.primitiveRestartEnable << '\n';
- s << "primitiveRestartIndex = " << value.primitiveRestartIndex << '\n';
+ s << "VkRect2D = {\n";
+ s << "offset = " << value.offset << '\n';
+ s << "extent = " << value.extent << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineTessStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDynamicViewportStateCreateInfo& value)
{
- s << "VkPipelineTessStateCreateInfo = {\n";
+ s << "VkDynamicViewportStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "patchControlPoints = " << value.patchControlPoints << '\n';
+ s << "viewportAndScissorCount = " << value.viewportAndScissorCount << '\n';
+ s << "pViewports = " << value.pViewports << '\n';
+ s << "pScissors = " << value.pScissors << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineVpStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDynamicRasterStateCreateInfo& value)
{
- s << "VkPipelineVpStateCreateInfo = {\n";
+ s << "VkDynamicRasterStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "viewportCount = " << value.viewportCount << '\n';
- s << "clipOrigin = " << value.clipOrigin << '\n';
- s << "depthMode = " << value.depthMode << '\n';
+ s << "depthBias = " << value.depthBias << '\n';
+ s << "depthBiasClamp = " << value.depthBiasClamp << '\n';
+ s << "slopeScaledDepthBias = " << value.slopeScaledDepthBias << '\n';
+ s << "lineWidth = " << value.lineWidth << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineRsStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDynamicColorBlendStateCreateInfo& value)
{
- s << "VkPipelineRsStateCreateInfo = {\n";
+ s << "VkDynamicColorBlendStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "depthClipEnable = " << value.depthClipEnable << '\n';
- s << "rasterizerDiscardEnable = " << value.rasterizerDiscardEnable << '\n';
- s << "programPointSize = " << value.programPointSize << '\n';
- s << "pointOrigin = " << value.pointOrigin << '\n';
- s << "provokingVertex = " << value.provokingVertex << '\n';
- s << "fillMode = " << value.fillMode << '\n';
- s << "cullMode = " << value.cullMode << '\n';
- s << "frontFace = " << value.frontFace << '\n';
+ s << "blendConst = " << tcu::formatArray(DE_ARRAY_BEGIN(value.blendConst), DE_ARRAY_END(value.blendConst)) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineMsStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDynamicDepthStencilStateCreateInfo& value)
{
- s << "VkPipelineMsStateCreateInfo = {\n";
+ s << "VkDynamicDepthStencilStateCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "samples = " << value.samples << '\n';
- s << "multisampleEnable = " << value.multisampleEnable << '\n';
- s << "sampleShadingEnable = " << value.sampleShadingEnable << '\n';
- s << "minSampleShading = " << value.minSampleShading << '\n';
- s << "sampleMask = " << value.sampleMask << '\n';
+ s << "minDepthBounds = " << value.minDepthBounds << '\n';
+ s << "maxDepthBounds = " << value.maxDepthBounds << '\n';
+ s << "stencilReadMask = " << value.stencilReadMask << '\n';
+ s << "stencilWriteMask = " << value.stencilWriteMask << '\n';
+ s << "stencilFrontRef = " << value.stencilFrontRef << '\n';
+ s << "stencilBackRef = " << value.stencilBackRef << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineCbAttachmentState& value)
+std::ostream& operator<< (std::ostream& s, const VkAttachmentBindInfo& value)
{
- s << "VkPipelineCbAttachmentState = {\n";
- s << "blendEnable = " << value.blendEnable << '\n';
- s << "format = " << value.format << '\n';
- s << "srcBlendColor = " << value.srcBlendColor << '\n';
- s << "destBlendColor = " << value.destBlendColor << '\n';
- s << "blendOpColor = " << value.blendOpColor << '\n';
- s << "srcBlendAlpha = " << value.srcBlendAlpha << '\n';
- s << "destBlendAlpha = " << value.destBlendAlpha << '\n';
- s << "blendOpAlpha = " << value.blendOpAlpha << '\n';
- s << "channelWriteMask = " << getChannelFlagsStr(value.channelWriteMask) << '\n';
+ s << "VkAttachmentBindInfo = {\n";
+ s << "view = " << value.view << '\n';
+ s << "layout = " << value.layout << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineCbStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkFramebufferCreateInfo& value)
{
- s << "VkPipelineCbStateCreateInfo = {\n";
+ s << "VkFramebufferCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "alphaToCoverageEnable = " << value.alphaToCoverageEnable << '\n';
- s << "logicOpEnable = " << value.logicOpEnable << '\n';
- s << "logicOp = " << value.logicOp << '\n';
+ s << "renderPass = " << value.renderPass << '\n';
s << "attachmentCount = " << value.attachmentCount << '\n';
s << "pAttachments = " << value.pAttachments << '\n';
+ s << "width = " << value.width << '\n';
+ s << "height = " << value.height << '\n';
+ s << "layers = " << value.layers << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkStencilOpState& value)
-{
- s << "VkStencilOpState = {\n";
- s << "stencilFailOp = " << value.stencilFailOp << '\n';
- s << "stencilPassOp = " << value.stencilPassOp << '\n';
- s << "stencilDepthFailOp = " << value.stencilDepthFailOp << '\n';
- s << "stencilCompareOp = " << value.stencilCompareOp << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkPipelineDsStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkAttachmentDescription& value)
{
- s << "VkPipelineDsStateCreateInfo = {\n";
+ s << "VkAttachmentDescription = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
s << "format = " << value.format << '\n';
- s << "depthTestEnable = " << value.depthTestEnable << '\n';
- s << "depthWriteEnable = " << value.depthWriteEnable << '\n';
- s << "depthCompareOp = " << value.depthCompareOp << '\n';
- s << "depthBoundsEnable = " << value.depthBoundsEnable << '\n';
- s << "stencilTestEnable = " << value.stencilTestEnable << '\n';
- s << "front = " << value.front << '\n';
- s << "back = " << value.back << '\n';
+ s << "samples = " << value.samples << '\n';
+ s << "loadOp = " << value.loadOp << '\n';
+ s << "storeOp = " << value.storeOp << '\n';
+ s << "stencilLoadOp = " << value.stencilLoadOp << '\n';
+ s << "stencilStoreOp = " << value.stencilStoreOp << '\n';
+ s << "initialLayout = " << value.initialLayout << '\n';
+ s << "finalLayout = " << value.finalLayout << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineShaderStageCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkAttachmentReference& value)
{
- s << "VkPipelineShaderStageCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "shader = " << value.shader << '\n';
+ s << "VkAttachmentReference = {\n";
+ s << "attachment = " << value.attachment << '\n';
+ s << "layout = " << value.layout << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkGraphicsPipelineCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkSubpassDescription& value)
{
- s << "VkGraphicsPipelineCreateInfo = {\n";
+ s << "VkSubpassDescription = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "flags = " << getPipelineCreateFlagsStr(value.flags) << '\n';
- s << "layout = " << value.layout << '\n';
+ s << "pipelineBindPoint = " << value.pipelineBindPoint << '\n';
+ s << "flags = " << getSubpassDescriptionFlagsStr(value.flags) << '\n';
+ s << "inputCount = " << value.inputCount << '\n';
+ s << "inputAttachments = " << value.inputAttachments << '\n';
+ s << "colorCount = " << value.colorCount << '\n';
+ s << "colorAttachments = " << value.colorAttachments << '\n';
+ s << "resolveAttachments = " << value.resolveAttachments << '\n';
+ s << "depthStencilAttachment = " << value.depthStencilAttachment << '\n';
+ s << "preserveCount = " << value.preserveCount << '\n';
+ s << "preserveAttachments = " << value.preserveAttachments << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkPipelineLayoutCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkSubpassDependency& value)
{
- s << "VkPipelineLayoutCreateInfo = {\n";
+ s << "VkSubpassDependency = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "descriptorSetCount = " << value.descriptorSetCount << '\n';
- s << "pSetLayouts = " << value.pSetLayouts << '\n';
+ s << "srcSubpass = " << value.srcSubpass << '\n';
+ s << "destSubpass = " << value.destSubpass << '\n';
+ s << "srcStageMask = " << getPipelineStageFlagsStr(value.srcStageMask) << '\n';
+ s << "destStageMask = " << getPipelineStageFlagsStr(value.destStageMask) << '\n';
+ s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
+ s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
+ s << "byRegion = " << value.byRegion << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkSamplerCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkRenderPassCreateInfo& value)
{
- s << "VkSamplerCreateInfo = {\n";
+ s << "VkRenderPassCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "magFilter = " << value.magFilter << '\n';
- s << "minFilter = " << value.minFilter << '\n';
- s << "mipMode = " << value.mipMode << '\n';
- s << "addressU = " << value.addressU << '\n';
- s << "addressV = " << value.addressV << '\n';
- s << "addressW = " << value.addressW << '\n';
- s << "mipLodBias = " << value.mipLodBias << '\n';
- s << "maxAnisotropy = " << value.maxAnisotropy << '\n';
- s << "compareOp = " << value.compareOp << '\n';
- s << "minLod = " << value.minLod << '\n';
- s << "maxLod = " << value.maxLod << '\n';
- s << "borderColor = " << value.borderColor << '\n';
+ s << "attachmentCount = " << value.attachmentCount << '\n';
+ s << "pAttachments = " << value.pAttachments << '\n';
+ s << "subpassCount = " << value.subpassCount << '\n';
+ s << "pSubpasses = " << value.pSubpasses << '\n';
+ s << "dependencyCount = " << value.dependencyCount << '\n';
+ s << "pDependencies = " << value.pDependencies << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDynamicVpStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkCmdPoolCreateInfo& value)
{
- s << "VkDynamicVpStateCreateInfo = {\n";
+ s << "VkCmdPoolCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "viewportAndScissorCount = " << value.viewportAndScissorCount << '\n';
- s << "pViewports = " << value.pViewports << '\n';
- s << "pScissors = " << value.pScissors << '\n';
+ s << "queueFamilyIndex = " << value.queueFamilyIndex << '\n';
+ s << "flags = " << getCmdPoolCreateFlagsStr(value.flags) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDynamicRsStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkCmdBufferCreateInfo& value)
{
- s << "VkDynamicRsStateCreateInfo = {\n";
+ s << "VkCmdBufferCreateInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "depthBias = " << value.depthBias << '\n';
- s << "depthBiasClamp = " << value.depthBiasClamp << '\n';
- s << "slopeScaledDepthBias = " << value.slopeScaledDepthBias << '\n';
- s << "pointSize = " << value.pointSize << '\n';
- s << "pointFadeThreshold = " << value.pointFadeThreshold << '\n';
- s << "lineWidth = " << value.lineWidth << '\n';
+ s << "cmdPool = " << value.cmdPool << '\n';
+ s << "level = " << value.level << '\n';
+ s << "flags = " << value.flags << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDynamicCbStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkCmdBufferBeginInfo& value)
{
- s << "VkDynamicCbStateCreateInfo = {\n";
+ s << "VkCmdBufferBeginInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "blendConst = " << tcu::formatArray(DE_ARRAY_BEGIN(value.blendConst), DE_ARRAY_END(value.blendConst)) << '\n';
+ s << "flags = " << getCmdBufferOptimizeFlagsStr(value.flags) << '\n';
+ s << "renderPass = " << value.renderPass << '\n';
+ s << "framebuffer = " << value.framebuffer << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDynamicDsStateCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value)
{
- s << "VkDynamicDsStateCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "minDepth = " << value.minDepth << '\n';
- s << "maxDepth = " << value.maxDepth << '\n';
- s << "stencilReadMask = " << value.stencilReadMask << '\n';
- s << "stencilWriteMask = " << value.stencilWriteMask << '\n';
- s << "stencilFrontRef = " << value.stencilFrontRef << '\n';
- s << "stencilBackRef = " << value.stencilBackRef << '\n';
+ s << "VkBufferCopy = {\n";
+ s << "srcOffset = " << value.srcOffset << '\n';
+ s << "destOffset = " << value.destOffset << '\n';
+ s << "copySize = " << value.copySize << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkCmdBufferCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkImageCopy& value)
{
- s << "VkCmdBufferCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "queueNodeIndex = " << value.queueNodeIndex << '\n';
- s << "flags = " << value.flags << '\n';
+ s << "VkImageCopy = {\n";
+ s << "srcSubresource = " << value.srcSubresource << '\n';
+ s << "srcOffset = " << value.srcOffset << '\n';
+ s << "destSubresource = " << value.destSubresource << '\n';
+ s << "destOffset = " << value.destOffset << '\n';
+ s << "extent = " << value.extent << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkCmdBufferBeginInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkImageBlit& value)
{
- s << "VkCmdBufferBeginInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "flags = " << getCmdBufferOptimizeFlagsStr(value.flags) << '\n';
+ s << "VkImageBlit = {\n";
+ s << "srcSubresource = " << value.srcSubresource << '\n';
+ s << "srcOffset = " << value.srcOffset << '\n';
+ s << "srcExtent = " << value.srcExtent << '\n';
+ s << "destSubresource = " << value.destSubresource << '\n';
+ s << "destOffset = " << value.destOffset << '\n';
+ s << "destExtent = " << value.destExtent << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkRenderPassBegin& value)
+std::ostream& operator<< (std::ostream& s, const VkBufferImageCopy& value)
{
- s << "VkRenderPassBegin = {\n";
- s << "renderPass = " << value.renderPass << '\n';
- s << "framebuffer = " << value.framebuffer << '\n';
+ s << "VkBufferImageCopy = {\n";
+ s << "bufferOffset = " << value.bufferOffset << '\n';
+ s << "bufferRowLength = " << value.bufferRowLength << '\n';
+ s << "bufferImageHeight = " << value.bufferImageHeight << '\n';
+ s << "imageSubresource = " << value.imageSubresource << '\n';
+ s << "imageOffset = " << value.imageOffset << '\n';
+ s << "imageExtent = " << value.imageExtent << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkCmdBufferGraphicsBeginInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkClearColorValue& value)
{
- s << "VkCmdBufferGraphicsBeginInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "renderPassContinue = " << value.renderPassContinue << '\n';
+ s << "VkClearColorValue = {\n";
+ s << "f32 = " << tcu::formatArray(DE_ARRAY_BEGIN(value.f32), DE_ARRAY_END(value.f32)) << '\n';
+ s << "s32 = " << tcu::formatArray(DE_ARRAY_BEGIN(value.s32), DE_ARRAY_END(value.s32)) << '\n';
+ s << "u32 = " << tcu::formatArray(DE_ARRAY_BEGIN(value.u32), DE_ARRAY_END(value.u32)) << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkClearColor& value)
+std::ostream& operator<< (std::ostream& s, const VkRect3D& value)
{
- s << "VkClearColor = {\n";
- s << "color = " << value.color << '\n';
- s << "useRawValue = " << value.useRawValue << '\n';
+ s << "VkRect3D = {\n";
+ s << "offset = " << value.offset << '\n';
+ s << "extent = " << value.extent << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkRenderPassCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkImageResolve& value)
{
- s << "VkRenderPassCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "renderArea = " << value.renderArea << '\n';
- s << "colorAttachmentCount = " << value.colorAttachmentCount << '\n';
+ s << "VkImageResolve = {\n";
+ s << "srcSubresource = " << value.srcSubresource << '\n';
+ s << "srcOffset = " << value.srcOffset << '\n';
+ s << "destSubresource = " << value.destSubresource << '\n';
+ s << "destOffset = " << value.destOffset << '\n';
s << "extent = " << value.extent << '\n';
- s << "sampleCount = " << value.sampleCount << '\n';
- s << "layers = " << value.layers << '\n';
- s << "pColorFormats = " << value.pColorFormats << '\n';
- s << "pColorLayouts = " << value.pColorLayouts << '\n';
- s << "pColorLoadOps = " << value.pColorLoadOps << '\n';
- s << "pColorStoreOps = " << value.pColorStoreOps << '\n';
- s << "pColorLoadClearValues = " << value.pColorLoadClearValues << '\n';
- s << "depthStencilFormat = " << value.depthStencilFormat << '\n';
- s << "depthStencilLayout = " << value.depthStencilLayout << '\n';
- s << "depthLoadOp = " << value.depthLoadOp << '\n';
- s << "depthLoadClearValue = " << value.depthLoadClearValue << '\n';
- s << "depthStoreOp = " << value.depthStoreOp << '\n';
- s << "stencilLoadOp = " << value.stencilLoadOp << '\n';
- s << "stencilLoadClearValue = " << value.stencilLoadClearValue << '\n';
- s << "stencilStoreOp = " << value.stencilStoreOp << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkEventCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkClearDepthStencilValue& value)
{
- s << "VkEventCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "flags = " << value.flags << '\n';
+ s << "VkClearDepthStencilValue = {\n";
+ s << "depth = " << value.depth << '\n';
+ s << "stencil = " << value.stencil << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkFenceCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkClearValue& value)
{
- s << "VkFenceCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "flags = " << getFenceCreateFlagsStr(value.flags) << '\n';
+ s << "VkClearValue = {\n";
+ s << "color = " << value.color << '\n';
+ s << "ds = " << value.ds << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkSemaphoreCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value)
{
- s << "VkSemaphoreCreateInfo = {\n";
+ s << "VkRenderPassBeginInfo = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "initialCount = " << value.initialCount << '\n';
- s << "flags = " << getSemaphoreCreateFlagsStr(value.flags) << '\n';
+ s << "renderPass = " << value.renderPass << '\n';
+ s << "framebuffer = " << value.framebuffer << '\n';
+ s << "renderArea = " << value.renderArea << '\n';
+ s << "attachmentCount = " << value.attachmentCount << '\n';
+ s << "pAttachmentClearValues = " << value.pAttachmentClearValues << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkSemaphoreOpenInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkBufferMemoryBarrier& value)
{
- s << "VkSemaphoreOpenInfo = {\n";
+ s << "VkBufferMemoryBarrier = {\n";
s << "sType = " << value.sType << '\n';
s << "pNext = " << value.pNext << '\n';
- s << "sharedSemaphore = " << value.sharedSemaphore << '\n';
+ s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
+ s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
+ s << "srcQueueFamilyIndex = " << value.srcQueueFamilyIndex << '\n';
+ s << "destQueueFamilyIndex = " << value.destQueueFamilyIndex << '\n';
+ s << "buffer = " << value.buffer << '\n';
+ s << "offset = " << value.offset << '\n';
+ s << "size = " << value.size << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkQueryPoolCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDispatchIndirectCmd& value)
{
- s << "VkQueryPoolCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "queryType = " << value.queryType << '\n';
- s << "slots = " << value.slots << '\n';
- s << "pipelineStatistics = " << getQueryPipelineStatisticFlagsStr(value.pipelineStatistics) << '\n';
+ s << "VkDispatchIndirectCmd = {\n";
+ s << "x = " << value.x << '\n';
+ s << "y = " << value.y << '\n';
+ s << "z = " << value.z << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkFramebufferCreateInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCmd& value)
{
- s << "VkFramebufferCreateInfo = {\n";
- s << "sType = " << value.sType << '\n';
- s << "pNext = " << value.pNext << '\n';
- s << "colorAttachmentCount = " << value.colorAttachmentCount << '\n';
- s << "pColorAttachments = " << value.pColorAttachments << '\n';
- s << "pDepthStencilAttachment = " << value.pDepthStencilAttachment << '\n';
- s << "sampleCount = " << value.sampleCount << '\n';
- s << "width = " << value.width << '\n';
- s << "height = " << value.height << '\n';
- s << "layers = " << value.layers << '\n';
+ s << "VkDrawIndexedIndirectCmd = {\n";
+ s << "indexCount = " << value.indexCount << '\n';
+ s << "instanceCount = " << value.instanceCount << '\n';
+ s << "firstIndex = " << value.firstIndex << '\n';
+ s << "vertexOffset = " << value.vertexOffset << '\n';
+ s << "firstInstance = " << value.firstInstance << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCmd& value)
+std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value)
{
- s << "VkDrawIndexedIndirectCmd = {\n";
- s << "indexCount = " << value.indexCount << '\n';
- s << "instanceCount = " << value.instanceCount << '\n';
- s << "firstIndex = " << value.firstIndex << '\n';
- s << "vertexOffset = " << value.vertexOffset << '\n';
- s << "firstInstance = " << value.firstInstance << '\n';
+ s << "VkImageMemoryBarrier = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
+ s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
+ s << "oldLayout = " << value.oldLayout << '\n';
+ s << "newLayout = " << value.newLayout << '\n';
+ s << "srcQueueFamilyIndex = " << value.srcQueueFamilyIndex << '\n';
+ s << "destQueueFamilyIndex = " << value.destQueueFamilyIndex << '\n';
+ s << "image = " << value.image << '\n';
+ s << "subresourceRange = " << value.subresourceRange << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDispatchIndirectCmd& value)
+std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value)
{
- s << "VkDispatchIndirectCmd = {\n";
- s << "x = " << value.x << '\n';
- s << "y = " << value.y << '\n';
- s << "z = " << value.z << '\n';
+ s << "VkMemoryBarrier = {\n";
+ s << "sType = " << value.sType << '\n';
+ s << "pNext = " << value.pNext << '\n';
+ s << "outputMask = " << getMemoryOutputFlagsStr(value.outputMask) << '\n';
+ s << "inputMask = " << getMemoryInputFlagsStr(value.inputMask) << '\n';
s << '}';
return s;
}
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-struct VkOffset2D
-{
- deInt32 x;
- deInt32 y;
-};
-
-struct VkOffset3D
+struct VkApplicationInfo
{
- deInt32 x;
- deInt32 y;
- deInt32 z;
+ VkStructureType sType;
+ const void* pNext;
+ const char* pAppName;
+ deUint32 appVersion;
+ const char* pEngineName;
+ deUint32 engineVersion;
+ deUint32 apiVersion;
};
-struct VkExtent2D
+struct VkAllocCallbacks
{
- deInt32 width;
- deInt32 height;
+ void* pUserData;
+ PFN_vkAllocFunction pfnAlloc;
+ PFN_vkFreeFunction pfnFree;
};
-struct VkExtent3D
+struct VkInstanceCreateInfo
{
- deInt32 width;
- deInt32 height;
- deInt32 depth;
+ VkStructureType sType;
+ const void* pNext;
+ const VkApplicationInfo* pAppInfo;
+ const VkAllocCallbacks* pAllocCb;
+ deUint32 layerCount;
+ const char*const* ppEnabledLayerNames;
+ deUint32 extensionCount;
+ const char*const* ppEnabledExtensionNames;
};
-struct VkViewport
-{
- float originX;
- float originY;
- float width;
- float height;
- float minDepth;
- float maxDepth;
+struct VkPhysicalDeviceFeatures
+{
+ 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;
};
-struct VkRect
+struct VkFormatProperties
{
- VkOffset2D offset;
- VkExtent2D extent;
+ VkFormatFeatureFlags linearTilingFeatures;
+ VkFormatFeatureFlags optimalTilingFeatures;
};
-struct VkChannelMapping
-{
- VkChannelSwizzle r;
- VkChannelSwizzle g;
- VkChannelSwizzle b;
- VkChannelSwizzle a;
+struct VkImageFormatProperties
+{
+ deUint64 maxResourceSize;
+ deUint32 maxSamples;
+};
+
+struct VkPhysicalDeviceLimits
+{
+ deUint32 maxImageDimension1D;
+ deUint32 maxImageDimension2D;
+ deUint32 maxImageDimension3D;
+ deUint32 maxImageDimensionCube;
+ deUint32 maxImageArrayLayers;
+ deUint32 maxTexelBufferSize;
+ deUint32 maxUniformBufferSize;
+ deUint32 maxStorageBufferSize;
+ deUint32 maxPushConstantsSize;
+ deUint32 maxMemoryAllocationCount;
+ VkDeviceSize bufferImageGranularity;
+ deUint32 maxBoundDescriptorSets;
+ deUint32 maxDescriptorSets;
+ deUint32 maxPerStageDescriptorSamplers;
+ deUint32 maxPerStageDescriptorUniformBuffers;
+ deUint32 maxPerStageDescriptorStorageBuffers;
+ deUint32 maxPerStageDescriptorSampledImages;
+ deUint32 maxPerStageDescriptorStorageImages;
+ deUint32 maxDescriptorSetSamplers;
+ deUint32 maxDescriptorSetUniformBuffers;
+ deUint32 maxDescriptorSetStorageBuffers;
+ deUint32 maxDescriptorSetSampledImages;
+ deUint32 maxDescriptorSetStorageImages;
+ deUint32 maxVertexInputAttributes;
+ deUint32 maxVertexInputAttributeOffset;
+ deUint32 maxVertexInputBindingStride;
+ deUint32 maxVertexOutputComponents;
+ deUint32 maxTessGenLevel;
+ deUint32 maxTessPatchSize;
+ deUint32 maxTessControlPerVertexInputComponents;
+ deUint32 maxTessControlPerVertexOutputComponents;
+ deUint32 maxTessControlPerPatchOutputComponents;
+ deUint32 maxTessControlTotalOutputComponents;
+ deUint32 maxTessEvaluationInputComponents;
+ deUint32 maxTessEvaluationOutputComponents;
+ deUint32 maxGeometryShaderInvocations;
+ deUint32 maxGeometryInputComponents;
+ deUint32 maxGeometryOutputComponents;
+ deUint32 maxGeometryOutputVertices;
+ deUint32 maxGeometryTotalOutputComponents;
+ deUint32 maxFragmentInputComponents;
+ deUint32 maxFragmentOutputBuffers;
+ deUint32 maxFragmentDualSourceBuffers;
+ deUint32 maxFragmentCombinedOutputResources;
+ deUint32 maxComputeSharedMemorySize;
+ deUint32 maxComputeWorkGroupCount[3];
+ deUint32 maxComputeWorkGroupInvocations;
+ deUint32 maxComputeWorkGroupSize[3];
+ deUint32 subPixelPrecisionBits;
+ deUint32 subTexelPrecisionBits;
+ deUint32 mipmapPrecisionBits;
+ deUint32 maxDrawIndexedIndexValue;
+ deUint32 maxDrawIndirectInstanceCount;
+ VkBool32 primitiveRestartForPatches;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ deUint32 maxViewports;
+ deUint32 maxDynamicViewportStates;
+ deUint32 maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ deUint32 viewportSubPixelBits;
+ deUint32 minMemoryMapAlignment;
+ deUint32 minTexelBufferOffsetAlignment;
+ deUint32 minUniformBufferOffsetAlignment;
+ deUint32 minStorageBufferOffsetAlignment;
+ deUint32 minTexelOffset;
+ deUint32 maxTexelOffset;
+ deUint32 minTexelGatherOffset;
+ deUint32 maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+ deUint32 subPixelInterpolationOffsetBits;
+ deUint32 maxFramebufferWidth;
+ deUint32 maxFramebufferHeight;
+ deUint32 maxFramebufferLayers;
+ deUint32 maxFramebufferColorSamples;
+ deUint32 maxFramebufferDepthSamples;
+ deUint32 maxFramebufferStencilSamples;
+ deUint32 maxColorAttachments;
+ deUint32 maxSampledImageColorSamples;
+ deUint32 maxSampledImageDepthSamples;
+ deUint32 maxSampledImageIntegerSamples;
+ deUint32 maxStorageImageSamples;
+ deUint32 maxSampleMaskWords;
+ deUint64 timestampFrequency;
+ deUint32 maxClipDistances;
+ deUint32 maxCullDistances;
+ deUint32 maxCombinedClipAndCullDistances;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
};
struct VkPhysicalDeviceProperties
deUint32 deviceId;
VkPhysicalDeviceType deviceType;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
- VkDeviceSize maxInlineMemoryUpdateSize;
- deUint32 maxBoundDescriptorSets;
- deUint32 maxThreadGroupSize;
- deUint64 timestampFrequency;
- deUint32 multiColorAttachmentClears;
- deUint32 maxDescriptorSets;
- deUint32 maxViewports;
- deUint32 maxColorAttachments;
-};
-
-struct VkPhysicalDevicePerformance
-{
- float maxDeviceClock;
- float aluPerClock;
- float texPerClock;
- float primsPerClock;
- float pixelsPerClock;
+ deUint8 pipelineCacheUUID[VK_UUID_LENGTH];
};
-struct VkPhysicalDeviceCompatibilityInfo
+struct VkPhysicalDeviceQueueProperties
{
- VkPhysicalDeviceCompatibilityFlags compatibilityFlags;
+ VkQueueFlags queueFlags;
+ deUint32 queueCount;
+ VkBool32 supportsTimestamps;
};
-struct VkExtensionProperties
+struct VkMemoryType
{
- char extName[VK_MAX_EXTENSION_NAME];
- deUint32 version;
+ VkMemoryPropertyFlags propertyFlags;
+ deUint32 heapIndex;
};
-struct VkApplicationInfo
+struct VkMemoryHeap
{
- VkStructureType sType;
- const void* pNext;
- const char* pAppName;
- deUint32 appVersion;
- const char* pEngineName;
- deUint32 engineVersion;
- deUint32 apiVersion;
+ VkDeviceSize size;
+ VkMemoryHeapFlags flags;
};
-struct VkAllocCallbacks
+struct VkPhysicalDeviceMemoryProperties
{
- void* pUserData;
- PFN_vkAllocFunction pfnAlloc;
- PFN_vkFreeFunction pfnFree;
+ deUint32 memoryTypeCount;
+ VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ deUint32 memoryHeapCount;
+ VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
};
struct VkDeviceQueueCreateInfo
{
- deUint32 queueNodeIndex;
+ deUint32 queueFamilyIndex;
deUint32 queueCount;
};
const void* pNext;
deUint32 queueRecordCount;
const VkDeviceQueueCreateInfo* pRequestedQueues;
+ deUint32 layerCount;
+ const char*const* ppEnabledLayerNames;
deUint32 extensionCount;
const char*const* ppEnabledExtensionNames;
+ const VkPhysicalDeviceFeatures* pEnabledFeatures;
VkDeviceCreateFlags flags;
};
-struct VkInstanceCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- const VkApplicationInfo* pAppInfo;
- const VkAllocCallbacks* pAllocCb;
- deUint32 extensionCount;
- const char*const* ppEnabledExtensionNames;
-};
-
-struct VkLayerCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- deUint32 layerCount;
- const char *const* ppActiveLayerNames;
-};
-
-struct VkPhysicalDeviceQueueProperties
+struct VkExtensionProperties
{
- VkQueueFlags queueFlags;
- deUint32 queueCount;
- deUint32 maxAtomicCounters;
- deUint32 supportsTimestamps;
- deUint32 maxMemReferences;
+ char extName[VK_MAX_EXTENSION_NAME];
+ deUint32 specVersion;
};
-struct VkPhysicalDeviceMemoryProperties
+struct VkLayerProperties
{
- deUint32 supportsMigration;
- deUint32 supportsPinning;
+ char layerName[VK_MAX_EXTENSION_NAME];
+ deUint32 specVersion;
+ deUint32 implVersion;
+ const char* description[VK_MAX_DESCRIPTION];
};
struct VkMemoryAllocInfo
{
- VkStructureType sType;
- const void* pNext;
- VkDeviceSize allocationSize;
- VkMemoryPropertyFlags memProps;
- VkMemoryPriority memPriority;
-};
-
-struct VkMemoryOpenInfo
-{
VkStructureType sType;
const void* pNext;
- VkDeviceMemory sharedMem;
+ VkDeviceSize allocationSize;
+ deUint32 memoryTypeIndex;
};
-struct VkPeerMemoryOpenInfo
+struct VkMappedMemoryRange
{
VkStructureType sType;
const void* pNext;
- VkDeviceMemory originalMem;
+ VkDeviceMemory mem;
+ VkDeviceSize offset;
+ VkDeviceSize size;
};
struct VkMemoryRequirements
{
- VkDeviceSize size;
- VkDeviceSize alignment;
- VkDeviceSize granularity;
- VkMemoryPropertyFlags memPropsAllowed;
- VkMemoryPropertyFlags memPropsRequired;
-};
-
-struct VkFormatProperties
-{
- VkFormatFeatureFlags linearTilingFeatures;
- VkFormatFeatureFlags optimalTilingFeatures;
+ VkDeviceSize size;
+ VkDeviceSize alignment;
+ deUint32 memoryTypeBits;
};
-struct VkBufferViewAttachInfo
+struct VkExtent3D
{
- VkStructureType sType;
- const void* pNext;
- VkBufferView view;
+ deInt32 width;
+ deInt32 height;
+ deInt32 depth;
};
-struct VkImageViewAttachInfo
+struct VkSparseImageFormatProperties
{
- VkStructureType sType;
- const void* pNext;
- VkImageView view;
- VkImageLayout layout;
+ VkImageAspect aspect;
+ VkExtent3D imageGranularity;
+ VkSparseImageFormatFlags flags;
};
-struct VkUpdateSamplers
+struct VkSparseImageMemoryRequirements
{
- VkStructureType sType;
- const void* pNext;
- deUint32 binding;
- deUint32 arrayIndex;
- deUint32 count;
- const VkSampler* pSamplers;
+ VkSparseImageFormatProperties formatProps;
+ deUint32 imageMipTailStartLOD;
+ VkDeviceSize imageMipTailSize;
+ VkDeviceSize imageMipTailOffset;
+ VkDeviceSize imageMipTailStride;
};
-struct VkSamplerImageViewInfo
+struct VkSparseMemoryBindInfo
{
- VkSampler sampler;
- const VkImageViewAttachInfo* pImageView;
+ VkDeviceSize offset;
+ VkDeviceSize memOffset;
+ VkDeviceMemory mem;
+ VkSparseMemoryBindFlags flags;
};
-struct VkUpdateSamplerTextures
+struct VkImageSubresource
{
- VkStructureType sType;
- const void* pNext;
- deUint32 binding;
- deUint32 arrayIndex;
- deUint32 count;
- const VkSamplerImageViewInfo* pSamplerImageViews;
+ VkImageAspect aspect;
+ deUint32 mipLevel;
+ deUint32 arraySlice;
};
-struct VkUpdateImages
+struct VkOffset3D
{
- VkStructureType sType;
- const void* pNext;
- VkDescriptorType descriptorType;
- deUint32 binding;
- deUint32 arrayIndex;
- deUint32 count;
- const VkImageViewAttachInfo* pImageViews;
+ deInt32 x;
+ deInt32 y;
+ deInt32 z;
};
-struct VkUpdateBuffers
+struct VkSparseImageMemoryBindInfo
{
- VkStructureType sType;
- const void* pNext;
- VkDescriptorType descriptorType;
- deUint32 binding;
- deUint32 arrayIndex;
- deUint32 count;
- const VkBufferViewAttachInfo* pBufferViews;
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+ VkDeviceSize memOffset;
+ VkDeviceMemory mem;
+ VkSparseMemoryBindFlags flags;
};
-struct VkUpdateAsCopy
+struct VkFenceCreateInfo
{
VkStructureType sType;
const void* pNext;
- VkDescriptorType descriptorType;
- VkDescriptorSet descriptorSet;
- deUint32 binding;
- deUint32 arrayElement;
- deUint32 count;
+ VkFenceCreateFlags flags;
};
-struct VkBufferCreateInfo
+struct VkSemaphoreCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- VkDeviceSize size;
- VkBufferUsageFlags usage;
- VkBufferCreateFlags flags;
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphoreCreateFlags flags;
};
-struct VkBufferViewCreateInfo
+struct VkEventCreateInfo
{
VkStructureType sType;
const void* pNext;
- VkBuffer buffer;
- VkBufferViewType viewType;
- VkFormat format;
- VkDeviceSize offset;
- VkDeviceSize range;
-};
-
-struct VkImageSubresource
-{
- VkImageAspect aspect;
- deUint32 mipLevel;
- deUint32 arraySlice;
+ VkEventCreateFlags flags;
};
-struct VkImageSubresourceRange
+struct VkQueryPoolCreateInfo
{
- VkImageAspect aspect;
- deUint32 baseMipLevel;
- deUint32 mipLevels;
- deUint32 baseArraySlice;
- deUint32 arraySize;
+ VkStructureType sType;
+ const void* pNext;
+ VkQueryType queryType;
+ deUint32 slots;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
};
-struct VkMemoryBarrier
+struct VkBufferCreateInfo
{
VkStructureType sType;
const void* pNext;
- VkMemoryOutputFlags outputMask;
- VkMemoryInputFlags inputMask;
+ VkDeviceSize size;
+ VkBufferUsageFlags usage;
+ VkBufferCreateFlags flags;
+ VkSharingMode sharingMode;
+ deUint32 queueFamilyCount;
+ const deUint32* pQueueFamilyIndices;
};
-struct VkBufferMemoryBarrier
+struct VkBufferViewCreateInfo
{
VkStructureType sType;
const void* pNext;
- VkMemoryOutputFlags outputMask;
- VkMemoryInputFlags inputMask;
VkBuffer buffer;
+ VkBufferViewType viewType;
+ VkFormat format;
VkDeviceSize offset;
- VkDeviceSize size;
-};
-
-struct VkImageMemoryBarrier
-{
- VkStructureType sType;
- const void* pNext;
- VkMemoryOutputFlags outputMask;
- VkMemoryInputFlags inputMask;
- VkImageLayout oldLayout;
- VkImageLayout newLayout;
- VkImage image;
- VkImageSubresourceRange subresourceRange;
+ VkDeviceSize range;
};
struct VkImageCreateInfo
VkImageTiling tiling;
VkImageUsageFlags usage;
VkImageCreateFlags flags;
-};
-
-struct VkPeerImageOpenInfo
-{
- VkImage originalImage;
+ VkSharingMode sharingMode;
+ deUint32 queueFamilyCount;
+ const deUint32* pQueueFamilyIndices;
};
struct VkSubresourceLayout
VkDeviceSize depthPitch;
};
+struct VkChannelMapping
+{
+ VkChannelSwizzle r;
+ VkChannelSwizzle g;
+ VkChannelSwizzle b;
+ VkChannelSwizzle a;
+};
+
+struct VkImageSubresourceRange
+{
+ VkImageAspect aspect;
+ deUint32 baseMipLevel;
+ deUint32 mipLevels;
+ deUint32 baseArraySlice;
+ deUint32 arraySize;
+};
+
struct VkImageViewCreateInfo
{
VkStructureType sType;
VkFormat format;
VkChannelMapping channels;
VkImageSubresourceRange subresourceRange;
- float minLod;
};
-struct VkColorAttachmentViewCreateInfo
+struct VkAttachmentViewCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- VkImage image;
- VkFormat format;
- deUint32 mipLevel;
- deUint32 baseArraySlice;
- deUint32 arraySize;
- VkImage msaaResolveImage;
- VkImageSubresourceRange msaaResolveSubResource;
+ VkStructureType sType;
+ const void* pNext;
+ VkImage image;
+ VkFormat format;
+ deUint32 mipLevel;
+ deUint32 baseArraySlice;
+ deUint32 arraySize;
+ VkAttachmentViewCreateFlags flags;
};
-struct VkDepthStencilViewCreateInfo
+struct VkShaderModuleCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- VkImage image;
- deUint32 mipLevel;
- deUint32 baseArraySlice;
- deUint32 arraySize;
- VkImage msaaResolveImage;
- VkImageSubresourceRange msaaResolveSubResource;
- VkDepthStencilViewCreateFlags flags;
+ VkStructureType sType;
+ const void* pNext;
+ deUintptr codeSize;
+ const void* pCode;
+ VkShaderModuleCreateFlags flags;
};
-struct VkColorAttachmentBindInfo
+struct VkShaderCreateInfo
{
- VkColorAttachmentView view;
- VkImageLayout layout;
+ VkStructureType sType;
+ const void* pNext;
+ VkShaderModule module;
+ const char* pName;
+ VkShaderCreateFlags flags;
};
-struct VkDepthStencilBindInfo
+struct VkPipelineCacheCreateInfo
{
- VkDepthStencilView view;
- VkImageLayout layout;
+ VkStructureType sType;
+ const void* pNext;
+ deUintptr initialSize;
+ const void* initialData;
+ deUintptr maxSize;
};
-struct VkBufferCopy
+struct VkSpecializationMapEntry
{
- VkDeviceSize srcOffset;
- VkDeviceSize destOffset;
- VkDeviceSize copySize;
+ deUint32 constantId;
+ deUintptr size;
+ deUint32 offset;
};
-struct VkImageMemoryBindInfo
-{
- VkImageSubresource subresource;
- VkOffset3D offset;
- VkExtent3D extent;
-};
-
-struct VkImageCopy
-{
- VkImageSubresource srcSubresource;
- VkOffset3D srcOffset;
- VkImageSubresource destSubresource;
- VkOffset3D destOffset;
- VkExtent3D extent;
-};
-
-struct VkImageBlit
-{
- VkImageSubresource srcSubresource;
- VkOffset3D srcOffset;
- VkExtent3D srcExtent;
- VkImageSubresource destSubresource;
- VkOffset3D destOffset;
- VkExtent3D destExtent;
-};
-
-struct VkBufferImageCopy
-{
- VkDeviceSize bufferOffset;
- VkImageSubresource imageSubresource;
- VkOffset3D imageOffset;
- VkExtent3D imageExtent;
-};
-
-struct VkImageResolve
-{
- VkImageSubresource srcSubresource;
- VkOffset3D srcOffset;
- VkImageSubresource destSubresource;
- VkOffset3D destOffset;
- VkExtent3D extent;
-};
-
-struct VkShaderCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- deUintptr codeSize;
- const void* pCode;
- VkShaderCreateFlags flags;
-};
-
-struct VkDescriptorSetLayoutBinding
-{
- VkDescriptorType descriptorType;
- deUint32 count;
- VkShaderStageFlags stageFlags;
- const VkSampler* pImmutableSamplers;
-};
-
-struct VkDescriptorSetLayoutCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- deUint32 count;
- const VkDescriptorSetLayoutBinding* pBinding;
-};
-
-struct VkDescriptorTypeCount
-{
- VkDescriptorType type;
- deUint32 count;
-};
-
-struct VkDescriptorPoolCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- deUint32 count;
- const VkDescriptorTypeCount* pTypeCount;
-};
-
-struct VkLinkConstBuffer
-{
- deUint32 bufferId;
- deUintptr bufferSize;
- const void* pBufferData;
-};
-
-struct VkSpecializationMapEntry
-{
- deUint32 constantId;
- deUint32 offset;
-};
-
-struct VkSpecializationInfo
+struct VkSpecializationInfo
{
deUint32 mapEntryCount;
const VkSpecializationMapEntry* pMap;
+ const deUintptr dataSize;
const void* pData;
};
-struct VkPipelineShader
+struct VkPipelineShaderStageCreateInfo
{
+ VkStructureType sType;
+ const void* pNext;
VkShaderStage stage;
VkShader shader;
- deUint32 linkConstBufferCount;
- const VkLinkConstBuffer* pLinkConstBufferInfo;
const VkSpecializationInfo* pSpecializationInfo;
};
-struct VkComputePipelineCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- VkPipelineShader cs;
- VkPipelineCreateFlags flags;
- VkPipelineLayout layout;
-};
-
struct VkVertexInputBindingDescription
{
deUint32 binding;
deUint32 offsetInBytes;
};
-struct VkPipelineVertexInputCreateInfo
+struct VkPipelineVertexInputStateCreateInfo
{
VkStructureType sType;
const void* pNext;
const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
};
-struct VkPipelineIaStateCreateInfo
+struct VkPipelineInputAssemblyStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPrimitiveTopology topology;
- deUint32 disableVertexReuse;
- deUint32 primitiveRestartEnable;
- deUint32 primitiveRestartIndex;
+ VkBool32 primitiveRestartEnable;
};
-struct VkPipelineTessStateCreateInfo
+struct VkPipelineTessellationStateCreateInfo
{
VkStructureType sType;
const void* pNext;
deUint32 patchControlPoints;
};
-struct VkPipelineVpStateCreateInfo
+struct VkPipelineViewportStateCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- deUint32 viewportCount;
- VkCoordinateOrigin clipOrigin;
- VkDepthMode depthMode;
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 viewportCount;
};
-struct VkPipelineRsStateCreateInfo
+struct VkPipelineRasterStateCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- deUint32 depthClipEnable;
- deUint32 rasterizerDiscardEnable;
- deUint32 programPointSize;
- VkCoordinateOrigin pointOrigin;
- VkProvokingVertex provokingVertex;
- VkFillMode fillMode;
- VkCullMode cullMode;
- VkFrontFace frontFace;
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 depthClipEnable;
+ VkBool32 rasterizerDiscardEnable;
+ VkFillMode fillMode;
+ VkCullMode cullMode;
+ VkFrontFace frontFace;
};
-struct VkPipelineMsStateCreateInfo
+struct VkPipelineMultisampleStateCreateInfo
{
VkStructureType sType;
const void* pNext;
- deUint32 samples;
- deUint32 multisampleEnable;
- deUint32 sampleShadingEnable;
+ deUint32 rasterSamples;
+ VkBool32 sampleShadingEnable;
float minSampleShading;
VkSampleMask sampleMask;
};
-struct VkPipelineCbAttachmentState
-{
- deUint32 blendEnable;
- VkFormat format;
- VkBlend srcBlendColor;
- VkBlend destBlendColor;
- VkBlendOp blendOpColor;
- VkBlend srcBlendAlpha;
- VkBlend destBlendAlpha;
- VkBlendOp blendOpAlpha;
- VkChannelFlags channelWriteMask;
-};
-
-struct VkPipelineCbStateCreateInfo
-{
- VkStructureType sType;
- const void* pNext;
- deUint32 alphaToCoverageEnable;
- deUint32 logicOpEnable;
- VkLogicOp logicOp;
- deUint32 attachmentCount;
- const VkPipelineCbAttachmentState* pAttachments;
-};
-
struct VkStencilOpState
{
VkStencilOp stencilFailOp;
VkCompareOp stencilCompareOp;
};
-struct VkPipelineDsStateCreateInfo
+struct VkPipelineDepthStencilStateCreateInfo
{
VkStructureType sType;
const void* pNext;
- VkFormat format;
- deUint32 depthTestEnable;
- deUint32 depthWriteEnable;
+ VkBool32 depthTestEnable;
+ VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
- deUint32 depthBoundsEnable;
- deUint32 stencilTestEnable;
+ VkBool32 depthBoundsEnable;
+ VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
};
-struct VkPipelineShaderStageCreateInfo
+struct VkPipelineColorBlendAttachmentState
{
- VkStructureType sType;
- const void* pNext;
- VkPipelineShader shader;
+ VkBool32 blendEnable;
+ VkBlend srcBlendColor;
+ VkBlend destBlendColor;
+ VkBlendOp blendOpColor;
+ VkBlend srcBlendAlpha;
+ VkBlend destBlendAlpha;
+ VkBlendOp blendOpAlpha;
+ VkChannelFlags channelWriteMask;
+};
+
+struct VkPipelineColorBlendStateCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 alphaToCoverageEnable;
+ VkBool32 logicOpEnable;
+ VkLogicOp logicOp;
+ deUint32 attachmentCount;
+ const VkPipelineColorBlendAttachmentState* pAttachments;
};
struct VkGraphicsPipelineCreateInfo
{
- VkStructureType sType;
- const void* pNext;
- VkPipelineCreateFlags flags;
- VkPipelineLayout layout;
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 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;
+ deUint32 subpass;
+ VkPipeline basePipelineHandle;
+ deInt32 basePipelineIndex;
+};
+
+struct VkComputePipelineCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineShaderStageCreateInfo cs;
+ VkPipelineCreateFlags flags;
+ VkPipelineLayout layout;
+ VkPipeline basePipelineHandle;
+ deInt32 basePipelineIndex;
+};
+
+struct VkPushConstantRange
+{
+ VkShaderStageFlags stageFlags;
+ deUint32 start;
+ deUint32 length;
};
struct VkPipelineLayoutCreateInfo
const void* pNext;
deUint32 descriptorSetCount;
const VkDescriptorSetLayout* pSetLayouts;
+ deUint32 pushConstantRangeCount;
+ const VkPushConstantRange* pPushConstantRanges;
};
struct VkSamplerCreateInfo
VkTexAddress addressV;
VkTexAddress addressW;
float mipLodBias;
- deUint32 maxAnisotropy;
+ float maxAnisotropy;
+ VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
VkBorderColor borderColor;
};
-struct VkDynamicVpStateCreateInfo
+struct VkDescriptorSetLayoutBinding
+{
+ VkDescriptorType descriptorType;
+ deUint32 arraySize;
+ VkShaderStageFlags stageFlags;
+ const VkSampler* pImmutableSamplers;
+};
+
+struct VkDescriptorSetLayoutCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 count;
+ const VkDescriptorSetLayoutBinding* pBinding;
+};
+
+struct VkDescriptorTypeCount
+{
+ VkDescriptorType type;
+ deUint32 count;
+};
+
+struct VkDescriptorPoolCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 count;
+ const VkDescriptorTypeCount* pTypeCount;
+};
+
+struct VkDescriptorInfo
+{
+ VkBufferView bufferView;
+ VkSampler sampler;
+ VkImageView imageView;
+ VkAttachmentView attachmentView;
+ VkImageLayout imageLayout;
+};
+
+struct VkWriteDescriptorSet
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet destSet;
+ deUint32 destBinding;
+ deUint32 destArrayElement;
+ deUint32 count;
+ VkDescriptorType descriptorType;
+ const VkDescriptorInfo* pDescriptors;
+};
+
+struct VkCopyDescriptorSet
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet srcSet;
+ deUint32 srcBinding;
+ deUint32 srcArrayElement;
+ VkDescriptorSet destSet;
+ deUint32 destBinding;
+ deUint32 destArrayElement;
+ deUint32 count;
+};
+
+struct VkViewport
+{
+ float originX;
+ float originY;
+ float width;
+ float height;
+ float minDepth;
+ float maxDepth;
+};
+
+struct VkOffset2D
+{
+ deInt32 x;
+ deInt32 y;
+};
+
+struct VkExtent2D
+{
+ deInt32 width;
+ deInt32 height;
+};
+
+struct VkRect2D
+{
+ VkOffset2D offset;
+ VkExtent2D extent;
+};
+
+struct VkDynamicViewportStateCreateInfo
{
VkStructureType sType;
const void* pNext;
deUint32 viewportAndScissorCount;
const VkViewport* pViewports;
- const VkRect* pScissors;
+ const VkRect2D* pScissors;
};
-struct VkDynamicRsStateCreateInfo
+struct VkDynamicRasterStateCreateInfo
{
VkStructureType sType;
const void* pNext;
float depthBias;
float depthBiasClamp;
float slopeScaledDepthBias;
- float pointSize;
- float pointFadeThreshold;
float lineWidth;
};
-struct VkDynamicCbStateCreateInfo
+struct VkDynamicColorBlendStateCreateInfo
{
VkStructureType sType;
const void* pNext;
float blendConst[4];
};
-struct VkDynamicDsStateCreateInfo
+struct VkDynamicDepthStencilStateCreateInfo
{
VkStructureType sType;
const void* pNext;
- float minDepth;
- float maxDepth;
+ float minDepthBounds;
+ float maxDepthBounds;
deUint32 stencilReadMask;
deUint32 stencilWriteMask;
deUint32 stencilFrontRef;
deUint32 stencilBackRef;
};
+struct VkAttachmentBindInfo
+{
+ VkAttachmentView view;
+ VkImageLayout layout;
+};
+
+struct VkFramebufferCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+ deUint32 attachmentCount;
+ const VkAttachmentBindInfo* pAttachments;
+ deUint32 width;
+ deUint32 height;
+ deUint32 layers;
+};
+
+struct VkAttachmentDescription
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkFormat format;
+ deUint32 samples;
+ VkAttachmentLoadOp loadOp;
+ VkAttachmentStoreOp storeOp;
+ VkAttachmentLoadOp stencilLoadOp;
+ VkAttachmentStoreOp stencilStoreOp;
+ VkImageLayout initialLayout;
+ VkImageLayout finalLayout;
+};
+
+struct VkAttachmentReference
+{
+ deUint32 attachment;
+ VkImageLayout layout;
+};
+
+struct VkSubpassDescription
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineBindPoint pipelineBindPoint;
+ VkSubpassDescriptionFlags flags;
+ deUint32 inputCount;
+ const VkAttachmentReference* inputAttachments;
+ deUint32 colorCount;
+ const VkAttachmentReference* colorAttachments;
+ const VkAttachmentReference* resolveAttachments;
+ VkAttachmentReference depthStencilAttachment;
+ deUint32 preserveCount;
+ const VkAttachmentReference* preserveAttachments;
+};
+
+struct VkSubpassDependency
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 srcSubpass;
+ deUint32 destSubpass;
+ VkPipelineStageFlags srcStageMask;
+ VkPipelineStageFlags destStageMask;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ VkBool32 byRegion;
+};
+
+struct VkRenderPassCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 attachmentCount;
+ const VkAttachmentDescription* pAttachments;
+ deUint32 subpassCount;
+ const VkSubpassDescription* pSubpasses;
+ deUint32 dependencyCount;
+ const VkSubpassDependency* pDependencies;
+};
+
+struct VkCmdPoolCreateInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 queueFamilyIndex;
+ VkCmdPoolCreateFlags flags;
+};
+
struct VkCmdBufferCreateInfo
{
VkStructureType sType;
const void* pNext;
- deUint32 queueNodeIndex;
+ VkCmdPool cmdPool;
+ VkCmdBufferLevel level;
VkCmdBufferCreateFlags flags;
};
VkStructureType sType;
const void* pNext;
VkCmdBufferOptimizeFlags flags;
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
};
-struct VkRenderPassBegin
+struct VkBufferCopy
{
- VkRenderPass renderPass;
- VkFramebuffer framebuffer;
+ VkDeviceSize srcOffset;
+ VkDeviceSize destOffset;
+ VkDeviceSize copySize;
};
-struct VkCmdBufferGraphicsBeginInfo
+struct VkImageCopy
{
- VkStructureType sType;
- const void* pNext;
- VkRenderPassBegin renderPassContinue;
+ VkImageSubresource srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresource destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D extent;
+};
+
+struct VkImageBlit
+{
+ VkImageSubresource srcSubresource;
+ VkOffset3D srcOffset;
+ VkExtent3D srcExtent;
+ VkImageSubresource destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D destExtent;
};
-struct VkClearColor
+struct VkBufferImageCopy
{
- VkClearColorValue color;
- deUint32 useRawValue;
+ VkDeviceSize bufferOffset;
+ deUint32 bufferRowLength;
+ deUint32 bufferImageHeight;
+ VkImageSubresource imageSubresource;
+ VkOffset3D imageOffset;
+ VkExtent3D imageExtent;
};
-struct VkRenderPassCreateInfo
+union VkClearColorValue
{
- VkStructureType sType;
- const void* pNext;
- VkRect renderArea;
- deUint32 colorAttachmentCount;
- VkExtent2D extent;
- deUint32 sampleCount;
- deUint32 layers;
- const VkFormat* pColorFormats;
- const VkImageLayout* pColorLayouts;
- const VkAttachmentLoadOp* pColorLoadOps;
- const VkAttachmentStoreOp* pColorStoreOps;
- const VkClearColor* pColorLoadClearValues;
- VkFormat depthStencilFormat;
- VkImageLayout depthStencilLayout;
- VkAttachmentLoadOp depthLoadOp;
- float depthLoadClearValue;
- VkAttachmentStoreOp depthStoreOp;
- VkAttachmentLoadOp stencilLoadOp;
- deUint32 stencilLoadClearValue;
- VkAttachmentStoreOp stencilStoreOp;
+ float f32[4];
+ deInt32 s32[4];
+ deUint32 u32[4];
};
-struct VkEventCreateInfo
+struct VkRect3D
{
- VkStructureType sType;
- const void* pNext;
- VkEventCreateFlags flags;
+ VkOffset3D offset;
+ VkExtent3D extent;
};
-struct VkFenceCreateInfo
+struct VkImageResolve
{
- VkStructureType sType;
- const void* pNext;
- VkFenceCreateFlags flags;
+ VkImageSubresource srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresource destSubresource;
+ VkOffset3D destOffset;
+ VkExtent3D extent;
};
-struct VkSemaphoreCreateInfo
+struct VkClearDepthStencilValue
{
- VkStructureType sType;
- const void* pNext;
- deUint32 initialCount;
- VkSemaphoreCreateFlags flags;
+ float depth;
+ deUint32 stencil;
};
-struct VkSemaphoreOpenInfo
+union VkClearValue
{
- VkStructureType sType;
- const void* pNext;
- VkSemaphore sharedSemaphore;
+ VkClearColorValue color;
+ VkClearDepthStencilValue ds;
};
-struct VkQueryPoolCreateInfo
+struct VkRenderPassBeginInfo
{
- VkStructureType sType;
- const void* pNext;
- VkQueryType queryType;
- deUint32 slots;
- VkQueryPipelineStatisticFlags pipelineStatistics;
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
+ VkRect2D renderArea;
+ deUint32 attachmentCount;
+ const VkClearValue* pAttachmentClearValues;
};
-struct VkFramebufferCreateInfo
+struct VkBufferMemoryBarrier
{
- VkStructureType sType;
- const void* pNext;
- deUint32 colorAttachmentCount;
- const VkColorAttachmentBindInfo* pColorAttachments;
- const VkDepthStencilBindInfo* pDepthStencilAttachment;
- deUint32 sampleCount;
- deUint32 width;
- deUint32 height;
- deUint32 layers;
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ deUint32 srcQueueFamilyIndex;
+ deUint32 destQueueFamilyIndex;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize size;
};
-struct VkDrawIndirectCmd
+struct VkDispatchIndirectCmd
{
- deUint32 vertexCount;
- deUint32 instanceCount;
- deUint32 firstVertex;
- deUint32 firstInstance;
+ deUint32 x;
+ deUint32 y;
+ deUint32 z;
};
struct VkDrawIndexedIndirectCmd
deUint32 firstInstance;
};
-struct VkDispatchIndirectCmd
+struct VkDrawIndirectCmd
{
- deUint32 x;
- deUint32 y;
- deUint32 z;
+ deUint32 vertexCount;
+ deUint32 instanceCount;
+ deUint32 firstVertex;
+ deUint32 firstInstance;
+};
+
+struct VkImageMemoryBarrier
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ deUint32 srcQueueFamilyIndex;
+ deUint32 destQueueFamilyIndex;
+ VkImage image;
+ VkImageSubresourceRange subresourceRange;
+};
+
+struct VkMemoryBarrier
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
};
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult getPhysicalDeviceInfo (VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const = 0;
-virtual VkResult destroyDevice (VkDevice device) const = 0;
-virtual VkResult getGlobalExtensionInfo (VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult getPhysicalDeviceExtensionInfo (VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, deUint32 extensionIndex, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult enumerateLayers (VkPhysicalDevice physicalDevice, deUintptr maxStringSize, deUintptr* pLayerCount, char* const* pOutLayers, void* pReserved) const = 0;
-virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueNodeIndex, deUint32 queueIndex, VkQueue* pQueue) const = 0;
-virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const = 0;
-virtual VkResult queueAddMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const = 0;
-virtual VkResult queueRemoveMemReferences (VkQueue queue, deUint32 count, const VkDeviceMemory* pMems) const = 0;
-virtual VkResult queueWaitIdle (VkQueue queue) const = 0;
-virtual VkResult deviceWaitIdle (VkDevice device) const = 0;
-virtual VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const = 0;
-virtual VkResult freeMemory (VkDevice device, VkDeviceMemory mem) const = 0;
-virtual VkResult setMemoryPriority (VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) const = 0;
-virtual VkResult mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const = 0;
-virtual VkResult unmapMemory (VkDevice device, VkDeviceMemory mem) const = 0;
-virtual VkResult flushMappedMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) const = 0;
-virtual VkResult pinSystemMemory (VkDevice device, const void* pSysMem, deUintptr memSize, VkDeviceMemory* pMem) const = 0;
-virtual VkResult getMultiDeviceCompatibility (VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo) const = 0;
-virtual VkResult openSharedMemory (VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const = 0;
-virtual VkResult openSharedSemaphore (VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) const = 0;
-virtual VkResult openPeerMemory (VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) const = 0;
-virtual VkResult openPeerImage (VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) const = 0;
-virtual VkResult destroyObject (VkDevice device, VkObjectType objType, VkObject object) const = 0;
-virtual VkResult getObjectInfo (VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult queueBindObjectMemory (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
-virtual VkResult queueBindObjectMemoryRange (VkQueue queue, VkObjectType objType, VkObject object, deUint32 allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
-virtual VkResult queueBindImageMemoryRange (VkQueue queue, VkImage image, deUint32 allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
-virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const = 0;
-virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, VkFence* pFences) const = 0;
-virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const = 0;
-virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, deUint32 waitAll, deUint64 timeout) const = 0;
-virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const = 0;
-virtual VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const = 0;
-virtual VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const = 0;
-virtual VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const = 0;
-virtual VkResult getEventStatus (VkDevice device, VkEvent event) const = 0;
-virtual VkResult setEvent (VkDevice device, VkEvent event) const = 0;
-virtual VkResult resetEvent (VkDevice device, VkEvent event) const = 0;
-virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const = 0;
-virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const = 0;
-virtual VkResult getFormatInfo (VkDevice device, VkFormat format, VkFormatInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const = 0;
-virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const = 0;
-virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const = 0;
-virtual VkResult getImageSubresourceInfo (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const = 0;
-virtual VkResult createColorAttachmentView (VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) const = 0;
-virtual VkResult createDepthStencilView (VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) const = 0;
-virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const = 0;
-virtual VkResult createGraphicsPipeline (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const = 0;
-virtual VkResult createGraphicsPipelineDerivative (VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) const = 0;
-virtual VkResult createComputePipeline (VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) const = 0;
-virtual VkResult storePipeline (VkDevice device, VkPipeline pipeline, deUintptr* pDataSize, void* pData) const = 0;
-virtual VkResult loadPipeline (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline* pPipeline) const = 0;
-virtual VkResult loadPipelineDerivative (VkDevice device, deUintptr dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) const = 0;
-virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const = 0;
-virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const = 0;
-virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const = 0;
-virtual VkResult beginDescriptorPoolUpdate (VkDevice device, VkDescriptorUpdateMode updateMode) const = 0;
-virtual VkResult endDescriptorPoolUpdate (VkDevice device, VkCmdBuffer cmd) const = 0;
-virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const = 0;
-virtual VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const = 0;
-virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const = 0;
-virtual void clearDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) const = 0;
-virtual void updateDescriptors (VkDevice device, VkDescriptorSet descriptorSet, deUint32 updateCount, const void** ppUpdateArray) const = 0;
-virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) const = 0;
-virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) const = 0;
-virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) const = 0;
-virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) const = 0;
-virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const = 0;
-virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const = 0;
-virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const = 0;
-virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer) const = 0;
-virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const = 0;
-virtual void cmdBindDynamicStateObject (VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState) const = 0;
-virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const = 0;
-virtual void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const = 0;
-virtual void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const = 0;
-virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const = 0;
-virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const = 0;
-virtual void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const = 0;
-virtual void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const = 0;
-virtual void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const = 0;
-virtual void cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const = 0;
-virtual void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const = 0;
-virtual void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const = 0;
-virtual void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions) const = 0;
-virtual void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const = 0;
-virtual void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const = 0;
-virtual void cmdCloneImageData (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) const = 0;
-virtual void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const = 0;
-virtual void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const = 0;
-virtual void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
-virtual void cmdClearDepthStencil (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
-virtual void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const = 0;
-virtual void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const = 0;
-virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) const = 0;
-virtual void cmdWaitEvents (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 eventCount, const VkEvent* pEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const = 0;
-virtual void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, deUint32 pipeEventCount, const VkPipeEvent* pPipeEvents, deUint32 memBarrierCount, const void** ppMemBarriers) const = 0;
-virtual void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const = 0;
-virtual void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const = 0;
-virtual void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const = 0;
-virtual void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const = 0;
-virtual void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const = 0;
-virtual void cmdInitAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, const deUint32* pData) const = 0;
-virtual void cmdLoadAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) const = 0;
-virtual void cmdSaveAtomicCounters (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, deUint32 startCounter, deUint32 counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) const = 0;
-virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const = 0;
-virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const = 0;
-virtual void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) const = 0;
-virtual void cmdEndRenderPass (VkCmdBuffer cmdBuffer, VkRenderPass renderPass) const = 0;
+virtual VkResult destroyDevice (VkDevice device) const = 0;
+virtual VkResult getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const = 0;
+virtual VkResult getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties) const = 0;
+virtual VkResult getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties) const = 0;
+virtual VkResult getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties) const = 0;
+virtual VkResult getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const = 0;
+virtual VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) const = 0;
+virtual VkResult queueWaitIdle (VkQueue queue) const = 0;
+virtual VkResult deviceWaitIdle (VkDevice device) const = 0;
+virtual VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) const = 0;
+virtual VkResult freeMemory (VkDevice device, VkDeviceMemory mem) const = 0;
+virtual VkResult mapMemory (VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const = 0;
+virtual VkResult unmapMemory (VkDevice device, VkDeviceMemory mem) const = 0;
+virtual VkResult flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const = 0;
+virtual VkResult invalidateMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges) const = 0;
+virtual VkResult getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const = 0;
+virtual VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
+virtual VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) const = 0;
+virtual VkResult getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const = 0;
+virtual VkResult getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const = 0;
+virtual VkResult getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const = 0;
+virtual VkResult getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, deUint32 samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pNumProperties, VkSparseImageFormatProperties* pProperties) const = 0;
+virtual VkResult queueBindSparseBufferMemory (VkQueue queue, VkBuffer buffer, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const = 0;
+virtual VkResult queueBindSparseImageOpaqueMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo) const = 0;
+virtual VkResult queueBindSparseImageMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) const = 0;
+virtual VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) const = 0;
+virtual VkResult destroyFence (VkDevice device, VkFence fence) const = 0;
+virtual VkResult resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const = 0;
+virtual VkResult getFenceStatus (VkDevice device, VkFence fence) const = 0;
+virtual VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout) const = 0;
+virtual VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) const = 0;
+virtual VkResult destroySemaphore (VkDevice device, VkSemaphore semaphore) const = 0;
+virtual VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore) const = 0;
+virtual VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore) const = 0;
+virtual VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) const = 0;
+virtual VkResult destroyEvent (VkDevice device, VkEvent event) const = 0;
+virtual VkResult getEventStatus (VkDevice device, VkEvent event) const = 0;
+virtual VkResult setEvent (VkDevice device, VkEvent event) const = 0;
+virtual VkResult resetEvent (VkDevice device, VkEvent event) const = 0;
+virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) const = 0;
+virtual VkResult destroyQueryPool (VkDevice device, VkQueryPool queryPool) const = 0;
+virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags) const = 0;
+virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) const = 0;
+virtual VkResult destroyBuffer (VkDevice device, VkBuffer buffer) const = 0;
+virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) const = 0;
+virtual VkResult destroyBufferView (VkDevice device, VkBufferView bufferView) const = 0;
+virtual VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) const = 0;
+virtual VkResult destroyImage (VkDevice device, VkImage image) const = 0;
+virtual VkResult getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const = 0;
+virtual VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) const = 0;
+virtual VkResult destroyImageView (VkDevice device, VkImageView imageView) const = 0;
+virtual VkResult createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) const = 0;
+virtual VkResult destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView) const = 0;
+virtual VkResult createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) const = 0;
+virtual VkResult destroyShaderModule (VkDevice device, VkShaderModule shaderModule) const = 0;
+virtual VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) const = 0;
+virtual VkResult destroyShader (VkDevice device, VkShader shader) const = 0;
+virtual VkResult createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) const = 0;
+virtual VkResult destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache) const = 0;
+virtual deUintptr getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache) const = 0;
+virtual VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, void* pData) const = 0;
+virtual VkResult mergePipelineCaches (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches) const = 0;
+virtual VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const = 0;
+virtual VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) const = 0;
+virtual VkResult destroyPipeline (VkDevice device, VkPipeline pipeline) const = 0;
+virtual VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) const = 0;
+virtual VkResult destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout) const = 0;
+virtual VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) const = 0;
+virtual VkResult destroySampler (VkDevice device, VkSampler sampler) const = 0;
+virtual VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) const = 0;
+virtual VkResult destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout) const = 0;
+virtual VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) const = 0;
+virtual VkResult destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const = 0;
+virtual VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool) const = 0;
+virtual VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount) const = 0;
+virtual VkResult updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies) const = 0;
+virtual VkResult createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) const = 0;
+virtual VkResult destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState) const = 0;
+virtual VkResult createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) const = 0;
+virtual VkResult destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState) const = 0;
+virtual VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) const = 0;
+virtual VkResult destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) const = 0;
+virtual VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) const = 0;
+virtual VkResult destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) const = 0;
+virtual VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) const = 0;
+virtual VkResult destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer) const = 0;
+virtual VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) const = 0;
+virtual VkResult destroyRenderPass (VkDevice device, VkRenderPass renderPass) const = 0;
+virtual VkResult getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const = 0;
+virtual VkResult createCommandPool (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) const = 0;
+virtual VkResult destroyCommandPool (VkDevice device, VkCmdPool cmdPool) const = 0;
+virtual VkResult resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) const = 0;
+virtual VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) const = 0;
+virtual VkResult destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer) const = 0;
+virtual VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) const = 0;
+virtual VkResult endCommandBuffer (VkCmdBuffer cmdBuffer) const = 0;
+virtual VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) const = 0;
+virtual void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const = 0;
+virtual void cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) const = 0;
+virtual void cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) const = 0;
+virtual void cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) const = 0;
+virtual void cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) const = 0;
+virtual void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const = 0;
+virtual void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const = 0;
+virtual void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const = 0;
+virtual void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount) const = 0;
+virtual void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount) const = 0;
+virtual void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const = 0;
+virtual void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride) const = 0;
+virtual void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z) const = 0;
+virtual void cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) const = 0;
+virtual void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const = 0;
+virtual void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const = 0;
+virtual void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkTexFilter filter) const = 0;
+virtual void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const = 0;
+virtual void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const = 0;
+virtual void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData) const = 0;
+virtual void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data) const = 0;
+virtual void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
+virtual void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const = 0;
+virtual void cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects) const = 0;
+virtual void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects) const = 0;
+virtual void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const = 0;
+virtual void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const = 0;
+virtual void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) const = 0;
+virtual void cmdWaitEvents (VkCmdBuffer cmdBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, deUint32 memBarrierCount, const void* const* ppMemBarriers) const = 0;
+virtual void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, deUint32 memBarrierCount, const void* const* ppMemBarriers) const = 0;
+virtual void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags) const = 0;
+virtual void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot) const = 0;
+virtual void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const = 0;
+virtual void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) const = 0;
+virtual void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) const = 0;
+virtual void cmdPushConstants (VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 start, deUint32 length, const void* values) const = 0;
+virtual void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) const = 0;
+virtual void cmdNextSubpass (VkCmdBuffer cmdBuffer, VkRenderPassContents contents) const = 0;
+virtual void cmdEndRenderPass (VkCmdBuffer cmdBuffer) const = 0;
+virtual void cmdExecuteCommands (VkCmdBuffer cmdBuffer, deUint32 cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) const = 0;
--- /dev/null
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ */
+virtual VkResult destroyInstance (VkInstance instance) const = 0;
+virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const = 0;
+virtual VkResult getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const = 0;
+virtual VkResult getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const = 0;
+virtual VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) const = 0;
+virtual VkResult getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) const = 0;
+virtual VkResult getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const = 0;
+virtual VkResult getPhysicalDeviceQueueCount (VkPhysicalDevice physicalDevice, deUint32* pCount) const = 0;
+virtual VkResult getPhysicalDeviceQueueProperties (VkPhysicalDevice physicalDevice, deUint32 count, VkPhysicalDeviceQueueProperties* pQueueProperties) const = 0;
+virtual VkResult getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const = 0;
+virtual PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, const char* pName) const = 0;
+virtual VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) const = 0;
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const = 0;
-virtual VkResult destroyInstance (VkInstance instance) const = 0;
-virtual VkResult enumeratePhysicalDevices (VkInstance instance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const = 0;
-virtual FunctionPtr getProcAddr (VkPhysicalDevice physicalDevice, const char* pName) const = 0;
+virtual VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) const = 0;
+virtual PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, const char* pName) const = 0;
PLATFORM_FUNCTIONS = [
"vkCreateInstance",
+ "vkGetInstanceProcAddr"
+]
+INSTANCE_FUNCTIONS = [
"vkDestroyInstance",
"vkEnumeratePhysicalDevices",
+ "vkGetPhysicalDeviceFeatures",
+ "vkGetPhysicalDeviceFormatProperties",
+ "vkGetPhysicalDeviceImageFormatProperties",
+ "vkGetPhysicalDeviceLimits",
+ "vkGetPhysicalDeviceProperties",
+ "vkGetPhysicalDeviceQueueCount",
+ "vkGetPhysicalDeviceQueueProperties",
+ "vkGetPhysicalDeviceMemoryProperties",
+ "vkCreateDevice",
+ "vkGetDeviceProcAddr"
]
-GET_PROC_ADDR = "vkGetProcAddr"
-
-OBJECT_TYPE_REPL = {
- "VkObject": None,
- "VkNonDispatchable": None,
- "VkDynamicStateObject": None,
- "VkCmdBuffer": "VK_OBJECT_TYPE_COMMAND_BUFFER",
-}
DEFINITIONS = [
"VK_API_VERSION",
"VK_MAX_PHYSICAL_DEVICE_NAME",
- "VK_MAX_EXTENSION_NAME"
+ "VK_MAX_EXTENSION_NAME",
+ "VK_UUID_LENGTH",
+ "VK_MAX_MEMORY_TYPES",
+ "VK_MAX_MEMORY_HEAPS",
+ "VK_MAX_DESCRIPTION"
]
class Handle:
- TYPE_ROOT = 0
- TYPE_DISP = 1
- TYPE_NONDISP = 2
+ TYPE_DISP = 0
+ TYPE_NONDISP = 1
- def __init__ (self, type, name, parent = None):
- assert (type == Handle.TYPE_ROOT) == (parent == None)
+ def __init__ (self, type, name):
self.type = type
self.name = name
- self.parent = parent
- def getObjectType (self):
- if self.name in OBJECT_TYPE_REPL:
- return OBJECT_TYPE_REPL[self.name]
- else:
- name = re.sub(r'([A-Z])', r'_\1', self.name)
- return "VK_OBJECT_TYPE_" + name[4:].upper()
+ def getHandleType (self):
+ name = re.sub(r'([A-Z])', r'_\1', self.name)
+ return "HANDLE_TYPE_" + name[4:].upper()
class Enum:
def __init__ (self, name, values):
self.type = type
self.name = name
-class Struct:
- def __init__ (self, name, members):
+class CompositeType:
+ CLASS_STRUCT = 0
+ CLASS_UNION = 1
+
+ def __init__ (self, typeClass, name, members):
+ self.typeClass = typeClass
self.name = name
self.members = members
+ def getClassName (self):
+ names = {CompositeType.CLASS_STRUCT: 'struct', CompositeType.CLASS_UNION: 'union'}
+ return names[self.typeClass]
+
class Function:
- TYPE_GET_PROC_ADDR = 0 # Special
- TYPE_PLATFORM = 1 # Not bound to VkPhysicalDevice
- TYPE_DEVICE = 2 # Bound to VkPhysicalDevice
+ TYPE_PLATFORM = 0 # Not bound to anything
+ TYPE_INSTANCE = 1 # Bound to VkInstance
+ TYPE_DEVICE = 2 # Bound to VkDevice
def __init__ (self, name, returnType, arguments):
self.name = name
self.arguments = arguments
def getType (self):
- if self.name == GET_PROC_ADDR:
- return Function.TYPE_GET_PROC_ADDR
- elif self.name in PLATFORM_FUNCTIONS:
+ if self.name in PLATFORM_FUNCTIONS:
return Function.TYPE_PLATFORM
+ elif self.name in INSTANCE_FUNCTIONS:
+ return Function.TYPE_INSTANCE
else:
return Function.TYPE_DEVICE
class API:
- def __init__ (self, definitions, handles, enums, bitfields, structs, functions):
+ def __init__ (self, definitions, handles, enums, bitfields, compositeTypes, functions):
self.definitions = definitions
self.handles = handles
self.enums = enums
self.bitfields = bitfields
- self.structs = structs
+ self.compositeTypes = compositeTypes
self.functions = functions
def readFile (filename):
fixedArgs = [Variable(fixupType(a.type), a.name) for a in function.arguments]
fixedReturnType = fixupType(function.returnType)
- if function.name == "vkGetProcAddr":
- fixedReturnType = "FunctionPtr"
-
return Function(function.name, fixedReturnType, fixedArgs)
def getInterfaceName (function):
# \note Parses raw enums, some are mapped to bitfields later
def parseEnums (src):
- matches = re.findall(r'typedef enum ' + IDENT_PTRN + r'\s*{([^}]*)}\s*(' + IDENT_PTRN + r')\s*;', src)
+ matches = re.findall(r'typedef enum\s*{([^}]*)}\s*(' + IDENT_PTRN + r')\s*;', src)
enums = []
for contents, name in matches:
return enums
-def parseStruct (name, src):
+def parseCompositeType (type, name, src):
# \todo [pyry] Array support is currently a hack (size coupled with name)
typeNamePtrn = r'(' + TYPE_PTRN + ')(\s' + IDENT_PTRN + r'(\[[^\]]+\])*)\s*;'
matches = re.findall(typeNamePtrn, src)
members = [Variable(fixupType(t.strip()), n.strip()) for t, n, a in matches]
- return Struct(name, members)
+ return CompositeType(type, name, members)
-def parseStructs (src):
- matches = re.findall(r'typedef struct ' + IDENT_PTRN + r'\s*{([^}]*)}\s*(' + IDENT_PTRN + r')\s*;', src)
- structs = []
+def parseCompositeTypes (src):
+ typeMap = { 'struct': CompositeType.CLASS_STRUCT, 'union': CompositeType.CLASS_UNION }
+ matches = re.findall(r'typedef (struct|union)\s*{([^}]*)}\s*(' + IDENT_PTRN + r')\s*;', src)
+ types = []
- for contents, name in matches:
- structs.append(parseStruct(name, contents))
+ for type, contents, name in matches:
+ types.append(parseCompositeType(typeMap[type], name, contents))
- return structs
+ return types
def parseHandles (src):
- matches = re.findall(r'VK_DEFINE_(NONDISP|DISP)_SUBCLASS_HANDLE\((' + IDENT_PTRN + r'),\s*(' + IDENT_PTRN + r')\)[ \t]*[\n\r]', src)
+ matches = re.findall(r'VK_DEFINE(_NONDISP|)_HANDLE\((' + IDENT_PTRN + r')\)[ \t]*[\n\r]', src)
handles = []
- typeMap = {'DISP': Handle.TYPE_DISP, 'NONDISP': Handle.TYPE_NONDISP}
- byName = {}
- root = Handle(Handle.TYPE_ROOT, 'VkObject')
+ typeMap = {'': Handle.TYPE_DISP, '_NONDISP': Handle.TYPE_NONDISP}
- byName[root.name] = root
- handles.append(root)
-
- for type, name, parentName in matches:
- parent = byName[parentName]
- handle = Handle(typeMap[type], name, parent)
-
- byName[handle.name] = handle
+ for type, name in matches:
+ handle = Handle(typeMap[type], name)
handles.append(handle)
return handles
enums.append(enum)
return API(
- definitions = definitions,
- handles = parseHandles(src),
- enums = enums,
- bitfields = bitfields,
- structs = parseStructs(src),
- functions = parseFunctions(src))
+ definitions = definitions,
+ handles = parseHandles(src),
+ enums = enums,
+ bitfields = bitfields,
+ compositeTypes = parseCompositeTypes(src),
+ functions = parseFunctions(src))
+
+def writeHandleType (api, filename):
+ def gen ():
+ yield "enum HandleType"
+ yield "{"
+ yield "\t%s = 0," % api.handles[0].getHandleType()
+ for handle in api.handles[1:]:
+ yield "\t%s," % handle.getHandleType()
+ yield "\tHANDLE_TYPE_LAST"
+ yield "};"
+ yield ""
+
+ writeInlFile(filename, INL_HEADER, gen())
def genEnumSrc (enum):
yield "enum %s" % enum.name
yield "};"
yield "typedef deUint32 %s;" % bitfield.name
-def genStructSrc (struct):
- yield "struct %s" % struct.name
+def genCompositeTypeSrc (type):
+ yield "%s %s" % (type.getClassName(), type.name)
yield "{"
- for line in indentLines(["\t%s\t%s;" % (m.type, m.name) for m in struct.members]):
+ for line in indentLines(["\t%s\t%s;" % (m.type, m.name) for m in type.members]):
yield line
yield "};"
def genHandlesSrc (handles):
def genLines (handles):
for handle in handles:
- if handle.type == Handle.TYPE_ROOT:
- yield "VK_DEFINE_BASE_HANDLE\t(%s);" % handle.name
- elif handle.type == Handle.TYPE_DISP:
- yield "VK_DEFINE_DISP_SUBCLASS_HANDLE\t(%s,\t%s);" % (handle.name, handle.parent.name)
+ if handle.type == Handle.TYPE_DISP:
+ yield "VK_DEFINE_HANDLE\t(%s,\t%s);" % (handle.name, handle.getHandleType())
elif handle.type == Handle.TYPE_NONDISP:
- yield "VK_DEFINE_NONDISP_SUBCLASS_HANDLE\t(%s,\t%s);" % (handle.name, handle.parent.name)
+ yield "VK_DEFINE_NONDISP_HANDLE\t(%s,\t%s);" % (handle.name, handle.getHandleType())
for line in indentLines(genLines(handles)):
yield line
for line in genBitfieldSrc(bitfield):
yield line
yield ""
- for line in indentLines(["VK_DEFINE_HANDLE_TYPE_TRAITS(%s);" % handle.name for handle in api.handles]):
- yield line
writeInlFile(filename, INL_HEADER, gen())
-def writeGetObjectTypeImpl (api, filename):
+def writeCompositeTypes (api, filename):
def gen ():
- for line in indentLines(["template<> VkObjectType\tgetObjectType<%sT>\t(void) { return %s;\t}" % (handle.name, handle.getObjectType()) for handle in api.handles if handle.getObjectType() != None]):
- yield line
-
- writeInlFile(filename, INL_HEADER, gen())
-
-def writeStructTypes (api, filename):
- def gen ():
- for struct in api.structs:
- for line in genStructSrc(struct):
+ for type in api.compositeTypes:
+ for line in genCompositeTypeSrc(type):
yield line
yield ""
for line in indentLines(["tcu::Format::Bitfield<32>\tget%sStr\t(%s value);" % (bitfield.name[2:], bitfield.name) for bitfield in api.bitfields]):
yield line
yield ""
- for line in indentLines(["std::ostream&\toperator<<\t(std::ostream& s, const %s& value);" % (s.name) for s in api.structs]):
+ for line in indentLines(["std::ostream&\toperator<<\t(std::ostream& s, const %s& value);" % (s.name) for s in api.compositeTypes]):
yield line
writeInlFile(filename, INL_HEADER, makeStrUtilProto())
def writeStrUtilImpl (api, filename):
def makeStrUtilImpl ():
- for line in indentLines(["template<> const char*\tgetTypeName<%sT>\t(void) { return \"%s\";\t}" % (handle.name, handle.name) for handle in api.handles]):
+ for line in indentLines(["template<> const char*\tgetTypeName<%s>\t(void) { return \"%s\";\t}" % (handle.name, handle.name) for handle in api.handles]):
yield line
for enum in api.enums:
bitfieldTypeNames = set([bitfield.name for bitfield in api.bitfields])
- for struct in api.structs:
+ for type in api.compositeTypes:
yield ""
- yield "std::ostream& operator<< (std::ostream& s, const %s& value)" % struct.name
+ yield "std::ostream& operator<< (std::ostream& s, const %s& value)" % type.name
yield "{"
- yield "\ts << \"%s = {\\n\";" % struct.name
- for member in struct.members:
+ yield "\ts << \"%s = {\\n\";" % type.name
+ for member in type.members:
memberName = member.name
valFmt = None
if member.type in bitfieldTypeNames:
writeInlFile(filename, INL_HEADER, makeStrUtilImpl())
class ConstructorFunction:
- def __init__ (self, name, objectType, iface, arguments):
+ def __init__ (self, type, name, objectType, iface, arguments):
+ self.type = type
self.name = name
self.objectType = objectType
self.iface = iface
def getConstructorFunctions (api):
funcs = []
for function in api.functions:
- if function.name[:8] == "vkCreate" or function.name == "vkAllocMemory":
+ if (function.name[:8] == "vkCreate" or function.name == "vkAllocMemory") and not "count" in [a.name for a in function.arguments]:
# \todo [pyry] Rather hacky
iface = None
if function.getType() == Function.TYPE_PLATFORM:
iface = Variable("const PlatformInterface&", "vk")
+ elif function.getType() == Function.TYPE_INSTANCE:
+ iface = Variable("const InstanceInterface&", "vk")
else:
iface = Variable("const DeviceInterface&", "vk")
objectType = function.arguments[-1].type.replace("*", "").strip()
arguments = function.arguments[:-1]
- funcs.append(ConstructorFunction(getInterfaceName(function), objectType, iface, arguments))
+ funcs.append(ConstructorFunction(function.getType(), getInterfaceName(function), objectType, iface, arguments))
return funcs
def writeRefUtilProto (api, filename):
def makeRefUtilProto ():
unindented = []
- for line in indentLines(["Move<%sT>\t%s\t(%s);" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments)) for function in functions]):
+ for line in indentLines(["Move<%s>\t%s\t(%s);" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments)) for function in functions]):
yield line
writeInlFile(filename, INL_HEADER, makeRefUtilProto())
functions = getConstructorFunctions(api)
def makeRefUtilImpl ():
+ yield "namespace refdetails"
+ yield "{"
+ yield ""
+
+ for function in api.functions:
+ if function.getType() == Function.TYPE_DEVICE \
+ and (function.name[:9] == "vkDestroy" or function.name == "vkFreeMemory") \
+ and not function.name == "vkDestroyDevice":
+ objectType = function.arguments[-1].type
+ yield "template<>"
+ yield "void Deleter<%s>::operator() (%s obj) const" % (objectType, objectType)
+ yield "{"
+ yield "\tDE_TEST_ASSERT(m_deviceIface->%s(m_device, obj) == VK_SUCCESS);" % (getInterfaceName(function))
+ yield "}"
+ yield ""
+
+ yield "} // refdetails"
+ yield ""
+
for function in functions:
- maybeDevice = ", device" if "device" in set([a.name for a in function.arguments]) else ""
+ dtorObj = "device" if function.type == Function.TYPE_DEVICE else "object"
- yield "Move<%sT> %s (%s)" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments))
+ yield "Move<%s> %s (%s)" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments))
yield "{"
yield "\t%s object = 0;" % function.objectType
yield "\tVK_CHECK(vk.%s(%s));" % (function.name, ", ".join([a.name for a in function.arguments] + ["&object"]))
- yield "\treturn Move<%sT>(vk%s, check<%sT>(object));" % (function.objectType, maybeDevice, function.objectType)
+ yield "\treturn Move<%s>(check<%s>(object), Deleter<%s>(vk, %s));" % (function.objectType, function.objectType, function.objectType, dtorObj)
yield "}"
yield ""
if __name__ == "__main__":
src = readFile(sys.argv[1])
api = parseAPI(src)
- platformFuncs = set([Function.TYPE_GET_PROC_ADDR, Function.TYPE_PLATFORM])
+ platformFuncs = set([Function.TYPE_PLATFORM])
+ instanceFuncs = set([Function.TYPE_INSTANCE])
deviceFuncs = set([Function.TYPE_DEVICE])
+ writeHandleType (api, os.path.join(VULKAN_DIR, "vkHandleType.inl"))
writeBasicTypes (api, os.path.join(VULKAN_DIR, "vkBasicTypes.inl"))
- writeStructTypes (api, os.path.join(VULKAN_DIR, "vkStructTypes.inl"))
- writeGetObjectTypeImpl (api, os.path.join(VULKAN_DIR, "vkGetObjectTypeImpl.inl"))
+ writeCompositeTypes (api, os.path.join(VULKAN_DIR, "vkStructTypes.inl"))
writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkVirtualPlatformInterface.inl"), functionTypes = platformFuncs, concrete = False)
+ writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkVirtualInstanceInterface.inl"), functionTypes = instanceFuncs, concrete = False)
writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkVirtualDeviceInterface.inl"), functionTypes = deviceFuncs, concrete = False)
writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkConcretePlatformInterface.inl"), functionTypes = platformFuncs, concrete = True)
+ writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkConcreteInstanceInterface.inl"), functionTypes = instanceFuncs, concrete = True)
writeInterfaceDecl (api, os.path.join(VULKAN_DIR, "vkConcreteDeviceInterface.inl"), functionTypes = deviceFuncs, concrete = True)
writeFunctionPtrTypes (api, os.path.join(VULKAN_DIR, "vkFunctionPointerTypes.inl"))
writeFunctionPointers (api, os.path.join(VULKAN_DIR, "vkPlatformFunctionPointers.inl"), functionTypes = platformFuncs)
+ writeFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInstanceFunctionPointers.inl"), functionTypes = instanceFuncs)
writeFunctionPointers (api, os.path.join(VULKAN_DIR, "vkDeviceFunctionPointers.inl"), functionTypes = deviceFuncs)
- writeInitFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInitPlatformFunctionPointers.inl"), functionTypes = set([Function.TYPE_PLATFORM])) # \note No vkGetProcAddr
+ writeInitFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInitPlatformFunctionPointers.inl"), functionTypes = platformFuncs)
+ writeInitFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInitInstanceFunctionPointers.inl"), functionTypes = instanceFuncs)
writeInitFunctionPointers (api, os.path.join(VULKAN_DIR, "vkInitDeviceFunctionPointers.inl"), functionTypes = deviceFuncs)
writeFuncPtrInterfaceImpl (api, os.path.join(VULKAN_DIR, "vkPlatformDriverImpl.inl"), functionTypes = platformFuncs, className = "PlatformDriver")
+ writeFuncPtrInterfaceImpl (api, os.path.join(VULKAN_DIR, "vkInstanceDriverImpl.inl"), functionTypes = instanceFuncs, className = "InstanceDriver")
writeFuncPtrInterfaceImpl (api, os.path.join(VULKAN_DIR, "vkDeviceDriverImpl.inl"), functionTypes = deviceFuncs, className = "DeviceDriver")
writeStrUtilProto (api, os.path.join(VULKAN_DIR, "vkStrUtil.inl"))
writeStrUtilImpl (api, os.path.join(VULKAN_DIR, "vkStrUtilImpl.inl"))
#include "tcuFormatUtil.hpp"
#include "deUniquePtr.hpp"
-#include "deSharedPtr.hpp"
namespace vkt
{
using std::vector;
using tcu::TestLog;
using de::UniquePtr;
-using de::MovePtr;
-// \todo [pyry] Want probably clean this up..
-
-typedef std::vector<de::SharedPtr<Allocation> > AllocationList;
-
-AllocationList allocate (Allocator& allocator, size_t numAllocations, const VkMemoryRequirements* allocRequirements, VkMemoryPropertyFlags memProps = 0u)
-{
- AllocationList allocs;
-
- for (size_t ndx = 0; ndx < numAllocations; ndx++)
- allocs.push_back(de::SharedPtr<Allocation>(allocate(allocator, allocRequirements[ndx], memProps).release()));
-
- return allocs;
-}
-
-AllocationList allocate (Allocator& allocator, const vector<VkMemoryRequirements>& allocRequirements, VkMemoryPropertyFlags memProps = 0u)
-{
- if (!allocRequirements.empty())
- return allocate(allocator, allocRequirements.size(), &allocRequirements[0], memProps);
- else
- return AllocationList();
-}
-
-tcu::TestStatus createSampler (Context& context)
+tcu::TestStatus createSamplerTest (Context& context)
{
const VkDevice vkDevice = context.getDevice();
const DeviceInterface& vk = context.getDeviceInterface();
{
const struct VkSamplerCreateInfo samplerInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VK_TEX_FILTER_NEAREST, // VkTexFilter magFilter;
- VK_TEX_FILTER_NEAREST, // VkTexFilter minFilter;
- VK_TEX_MIPMAP_MODE_BASE, // VkTexMipmapMode mipMode;
- VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressU;
- VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressV;
- VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressW;
- 0.0f, // float mipLodBias;
- 0u, // deUint32 maxAnisotropy;
- VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
- 0.0f, // float minLod;
- 0.0f, // float maxLod;
- VK_BORDER_COLOR_TRANSPARENT_BLACK, // VkBorderColor borderColor;
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_TEX_FILTER_NEAREST, // VkTexFilter magFilter;
+ VK_TEX_FILTER_NEAREST, // VkTexFilter minFilter;
+ VK_TEX_MIPMAP_MODE_BASE, // VkTexMipmapMode mipMode;
+ VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressU;
+ VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressV;
+ VK_TEX_ADDRESS_CLAMP, // VkTexAddress addressW;
+ 0.0f, // float mipLodBias;
+ 0.0f, // float maxAnisotropy;
+ DE_FALSE, // VkBool32 compareEnable;
+ VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
+ 0.0f, // float minLod;
+ 0.0f, // float maxLod;
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
};
- Move<VkSamplerT> tmpSampler = createSampler(vk, vkDevice, &samplerInfo);
- Move<VkSamplerT> tmp2Sampler (vk);
+ Move<VkSampler> tmpSampler = createSampler(vk, vkDevice, &samplerInfo);
+ Move<VkSampler> tmp2Sampler;
tmp2Sampler = tmpSampler;
- Unique<VkSamplerT> sampler (tmp2Sampler);
+ const Unique<VkSampler> sampler (tmp2Sampler);
}
return tcu::TestStatus::pass("Creating sampler succeeded");
"void main (void) { gl_Position = a_position; }\n");
}
-tcu::TestStatus createShader (Context& context)
+tcu::TestStatus createShaderModuleTest (Context& context)
{
- const VkDevice vkDevice = context.getDevice();
- const DeviceInterface& vk = context.getDeviceInterface();
- const Unique<VkShaderT> shader (createShader(vk, vkDevice, context.getBinaryCollection().get("test"), 0));
+ const VkDevice vkDevice = context.getDevice();
+ const DeviceInterface& vk = context.getDeviceInterface();
+ const Unique<VkShaderModule> shader (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("test"), 0));
- return tcu::TestStatus::pass("Creating shader succeeded");
+ return tcu::TestStatus::pass("Creating shader module succeeded");
}
void createTriangleProgs (SourceCollection& dst)
"void main (void) { o_color = vec4(1.0, 0.0, 1.0, 1.0); }\n");
}
-tcu::TestStatus renderTriangle (Context& context)
+tcu::TestStatus renderTriangleTest (Context& context)
{
const VkDevice vkDevice = context.getDevice();
const DeviceInterface& vk = context.getDeviceInterface();
const VkQueue queue = context.getUniversalQueue();
- SimpleAllocator memAlloc (vk, vkDevice);
+ const deUint32 queueIndex = context.getUniversalQueueIndex();
+ SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
const tcu::IVec2 renderSize (256, 256);
const tcu::Vec4 vertices[] =
(VkDeviceSize)sizeof(vertices), // VkDeviceSize size;
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
0u, // VkBufferCreateFlags flags;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 1u, // deUint32 queueFamilyCount;
+ &queueIndex, // const deUint32* pQueueFamilyIndices;
};
- const Unique<VkBufferT> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
- const AllocationList vertexBufferAllocs = allocate(memAlloc, getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, vertexBuffer), VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+ const Unique<VkBuffer> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
+ const UniquePtr<Allocation> vertexBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
const VkDeviceSize imageSizeBytes = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
const VkBufferCreateInfo readImageBufferParams =
imageSizeBytes, // VkDeviceSize size;
VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, // VkBufferUsageFlags usage;
0u, // VkBufferCreateFlags flags;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 1u, // deUint32 queueFamilyCount;
+ &queueIndex, // const deUint32* pQueueFamilyIndices;
};
- const Unique<VkBufferT> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
- const AllocationList readImageBufferAllocs = allocate(memAlloc, getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, vertexBuffer), VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT);
+ const Unique<VkBuffer> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
+ const UniquePtr<Allocation> readImageBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
const VkImageCreateInfo imageParams =
{
1u, // deUint32 samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
- 0u // VkImageCreateFlags flags;
+ 0u, // VkImageCreateFlags flags;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 1u, // deUint32 queueFamilyCount;
+ &queueIndex, // const deUint32* pQueueFamilyIndices;
};
- const Unique<VkImageT> image (createImage(vk, vkDevice, &imageParams));
- const AllocationList imageAllocs = allocate(memAlloc, getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, image));
-
- const VkColorAttachmentViewCreateInfo colorAttViewParams =
+ const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
+ const UniquePtr<Allocation> imageMemory (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), 0u));
+
+ const VkAttachmentDescription colorAttDesc =
+ {
+ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
+ 1u, // deUint32 samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
+ };
+ const VkAttachmentReference colorAttRef =
{
- VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- *image, // VkImage image;
- VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
- 0u, // deUint32 mipLevel;
- 0u, // deUint32 baseArraySlice;
- 1u, // deUint32 arraySize;
- DE_NULL, // VkImage msaaResolveImage;
- {
- VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
- 0u, // deUint32 baseMipLevel;
- 1u, // deUint32 mipLevels;
- 0u, // deUint32 baseArraySlice;
- 1u, // deUint32 arraySize;
- }, // VkImageSubresourceRange msaaResolveSubResource;
+ 0u, // deUint32 attachment;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout layout;
+ };
+ const VkSubpassDescription subpassDesc =
+ {
+ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
+ 0u, // VkSubpassDescriptionFlags flags;
+ 0u, // deUint32 inputCount;
+ DE_NULL, // const VkAttachmentReference* inputAttachments;
+ 1u, // deUint32 colorCount;
+ &colorAttRef, // const VkAttachmentReference* colorAttachments;
+ DE_NULL, // const VkAttachmentReference* resolveAttachments;
+ { ~0u, VK_IMAGE_LAYOUT_GENERAL }, // VkAttachmentReference depthStencilAttachment;
+ 0u, // deUint32 preserveCount;
+ DE_NULL, // const VkAttachmentReference* preserveAttachments;
};
- const Unique<VkColorAttachmentViewT> colorAttView (createColorAttachmentView(vk, vkDevice, &colorAttViewParams));
+ const VkRenderPassCreateInfo renderPassParams =
+ {
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 attachmentCount;
+ &colorAttDesc, // const VkAttachmentDescription* pAttachments;
+ 1u, // deUint32 subpassCount;
+ &subpassDesc, // const VkSubpassDescription* pSubpasses;
+ 0u, // deUint32 dependencyCount;
+ DE_NULL, // const VkSubpassDependency* pDependencies;
+ };
+ const Unique<VkRenderPass> renderPass (createRenderPass(vk, vkDevice, &renderPassParams));
+
+ const VkAttachmentViewCreateInfo colorAttViewParams =
+ {
+ VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *image, // VkImage image;
+ VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
+ 0u, // deUint32 mipLevel;
+ 0u, // deUint32 baseArraySlice;
+ 0u, // deUint32 arraySize;
+ 0u, // VkAttachmentViewCreateFlags flags;
+ };
+ const Unique<VkAttachmentView> colorAttView (createAttachmentView(vk, vkDevice, &colorAttViewParams));
- const Unique<VkShaderT> vertShader (createShader(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
- const Unique<VkShaderT> fragShader (createShader(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
+ const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
+ const VkShaderCreateInfo vertShaderParams =
+ {
+ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *vertShaderModule, // VkShaderModule module;
+ DE_NULL, // const char* pName;
+ 0u, // VkShaderCreateFlags flags;
+ };
+ const Unique<VkShader> vertShader (createShader(vk, vkDevice, &vertShaderParams));
+ const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
+ const VkShaderCreateInfo fragShaderParams =
+ {
+ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *fragShaderModule, // VkShaderModule module;
+ DE_NULL, // const char* pName;
+ 0u, // VkShaderCreateFlags flags;
+ };
+ const Unique<VkShader> fragShader (createShader(vk, vkDevice, &fragShaderParams));
// Pipeline layout
const VkPipelineLayoutCreateInfo pipelineLayoutParams =
DE_NULL, // const void* pNext;
0u, // deUint32 descriptorSetCount;
DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
+ 0u, // deUint32 pushConstantRangeCount;
+ DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
};
- const Unique<VkPipelineLayoutT> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
+ const Unique<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
// Pipeline
const VkSpecializationInfo emptyShaderSpecParams =
{
0u, // deUint32 mapEntryCount;
DE_NULL, // const VkSpecializationMapEntry* pMap;
+ 0, // const deUintptr dataSize;
DE_NULL, // const void* pData;
};
- const VkPipelineShaderStageCreateInfo vertShaderParams =
+ const VkPipelineShaderStageCreateInfo shaderStageParams[] =
{
- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
{
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
VK_SHADER_STAGE_VERTEX, // VkShaderStage stage;
*vertShader, // VkShader shader;
- 0u, // deUint32 linkConstBufferCount;
- DE_NULL, // const VkLinkConstBuffer* pLinkConstBufferInfo;
&emptyShaderSpecParams, // const VkSpecializationInfo* pSpecializationInfo;
- } // VkPipelineShader shader;
- };
- const VkPipelineShaderStageCreateInfo fragShaderParams =
- {
- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
- &vertShaderParams, // const void* pNext;
+ },
{
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ &vertShaderParams, // const void* pNext;
VK_SHADER_STAGE_FRAGMENT, // VkShaderStage stage;
*fragShader, // VkShader shader;
- 0u, // deUint32 linkConstBufferCount;
- DE_NULL, // const VkLinkConstBuffer* pLinkConstBufferInfo;
&emptyShaderSpecParams, // const VkSpecializationInfo* pSpecializationInfo;
- } // VkPipelineShader shader;
- };
- const VkPipelineDsStateCreateInfo depthStencilParams =
- {
- VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO, // VkStructureType sType;
- &fragShaderParams, // const void* pNext;
- VK_FORMAT_UNDEFINED, // VkFormat format;
- DE_FALSE, // deUint32 depthTestEnable;
- DE_FALSE, // deUint32 depthWriteEnable;
- VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
- DE_FALSE, // deUint32 depthBoundsEnable;
- DE_FALSE, // deUint32 stencilTestEnable;
+ }
+ };
+ const VkPipelineDepthStencilStateCreateInfo depthStencilParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
+ &fragShaderParams, // const void* pNext;
+ DE_FALSE, // deUint32 depthTestEnable;
+ DE_FALSE, // deUint32 depthWriteEnable;
+ VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
+ DE_FALSE, // deUint32 depthBoundsEnable;
+ DE_FALSE, // deUint32 stencilTestEnable;
{
- VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
- VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
- VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
- VK_COMPARE_OP_ALWAYS, // VkCompareOp stencilCompareOp;
- }, // VkStencilOpState front;
+ VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
+ VK_COMPARE_OP_ALWAYS, // VkCompareOp stencilCompareOp;
+ }, // VkStencilOpState front;
{
- VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
- VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
- VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
- VK_COMPARE_OP_ALWAYS, // VkCompareOp stencilCompareOp;
- } // VkStencilOpState back;
+ VK_STENCIL_OP_KEEP, // VkStencilOp stencilFailOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp stencilPassOp;
+ VK_STENCIL_OP_KEEP, // VkStencilOp stencilDepthFailOp;
+ VK_COMPARE_OP_ALWAYS, // VkCompareOp stencilCompareOp;
+ } // VkStencilOpState back;
};
- const VkPipelineVpStateCreateInfo viewportParams =
+ const VkPipelineViewportStateCreateInfo viewportParams =
{
- VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO, // VkStructureType sType;
- &depthStencilParams, // const void* pNext;
- 1u, // deUint32 viewportCount;
- VK_COORDINATE_ORIGIN_LOWER_LEFT, // VkCoordinateOrigin clipOrigin;
- VK_DEPTH_MODE_ZERO_TO_ONE, // VkDepthMode depthMode;
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
+ &depthStencilParams, // const void* pNext;
+ 1u, // deUint32 viewportCount;
};
- const VkPipelineMsStateCreateInfo multisampleParams =
- {
- VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO, // VkStructureType sType;
- &viewportParams, // const void* pNext;
- 1u, // deUint32 samples;
- DE_FALSE, // deUint32 multisampleEnable;
- DE_FALSE, // deUint32 sampleShadingEnable;
- 0.0f, // float minSampleShading;
- ~0u, // VkSampleMask sampleMask;
+ const VkPipelineMultisampleStateCreateInfo multisampleParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 rasterSamples;
+ DE_FALSE, // deUint32 sampleShadingEnable;
+ 0.0f, // float minSampleShading;
+ ~0u, // VkSampleMask sampleMask;
};
- const VkPipelineCbAttachmentState colorAttachmentParams =
+ const VkPipelineRasterStateCreateInfo rasterParams =
{
- DE_FALSE, // deUint32 blendEnable;
- VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
- VK_BLEND_ONE, // VkBlend srcBlendColor;
- VK_BLEND_ZERO, // VkBlend destBlendColor;
- VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
- VK_BLEND_ONE, // VkBlend srcBlendAlpha;
- VK_BLEND_ZERO, // VkBlend destBlendAlpha;
- VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
- VK_CHANNEL_R_BIT|VK_CHANNEL_G_BIT|VK_CHANNEL_B_BIT|VK_CHANNEL_A_BIT, // VkChannelFlags channelWriteMask;
- };
- const VkPipelineCbStateCreateInfo colorBufferParams =
- {
- VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO, // VkStructureType sType;
- &multisampleParams, // const void* pNext;
- DE_FALSE, // deUint32 alphaToCoverageEnable;
- DE_FALSE, // deUint32 logicOpEnable;
- VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
- 1u, // deUint32 attachmentCount;
- &colorAttachmentParams, // const VkPipelineCbAttachmentState* pAttachments;
- };
- const VkPipelineRsStateCreateInfo rasterParams =
- {
- VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO, // VkStructureType sType;
- &colorBufferParams, // const void* pNext;
+ VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
DE_TRUE, // deUint32 depthClipEnable;
DE_FALSE, // deUint32 rasterizerDiscardEnable;
- DE_FALSE, // deUint32 programPointSize;
- VK_COORDINATE_ORIGIN_LOWER_LEFT, // VkCoordinateOrigin pointOrigin;
- VK_PROVOKING_VERTEX_FIRST, // VkProvokingVertex provokingVertex;
VK_FILL_MODE_SOLID, // VkFillMode fillMode;
VK_CULL_MODE_NONE, // VkCullMode cullMode;
VK_FRONT_FACE_CCW, // VkFrontFace frontFace;
};
- const VkPipelineIaStateCreateInfo inputAssemblerParams =
+ const VkPipelineInputAssemblyStateCreateInfo inputAssemblyParams =
{
- VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO, // VkStructureType sType;
- &rasterParams, // const void* pNext;
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
- DE_FALSE, // deUint32 disableVertexReuse;
- DE_FALSE, // deUint32 primitiveRestartEnable;
- 0u, // deUint32 primitiveRestartIndex;
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
+ DE_FALSE, // deUint32 primitiveRestartEnable;
};
- const VkVertexInputBindingDescription vertexBinding0 =
+ const VkVertexInputBindingDescription vertexBinding0 =
{
0u, // deUint32 binding;
(deUint32)sizeof(tcu::Vec4), // deUint32 strideInBytes;
VK_VERTEX_INPUT_STEP_RATE_VERTEX, // VkVertexInputStepRate stepRate;
};
- const VkVertexInputAttributeDescription vertexAttrib0 =
+ const VkVertexInputAttributeDescription vertexAttrib0 =
{
0u, // deUint32 location;
0u, // deUint32 binding;
VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
0u, // deUint32 offsetInBytes;
};
- const VkPipelineVertexInputCreateInfo vertexInputInfo =
+ const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 bindingCount;
+ &vertexBinding0, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ 1u, // deUint32 attributeCount;
+ &vertexAttrib0, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ };
+ const VkPipelineColorBlendAttachmentState attBlendParams =
{
- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO, // VkStructureType sType;
- &inputAssemblerParams, // const void* pNext;
- 1u, // deUint32 bindingCount;
- &vertexBinding0, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
- 1u, // deUint32 attributeCount;
- &vertexAttrib0, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ DE_FALSE, // deUint32 blendEnable;
+ VK_BLEND_ONE, // VkBlend srcBlendColor;
+ VK_BLEND_ZERO, // VkBlend destBlendColor;
+ VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
+ VK_BLEND_ONE, // VkBlend srcBlendAlpha;
+ VK_BLEND_ZERO, // VkBlend destBlendAlpha;
+ VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
+ VK_CHANNEL_R_BIT|VK_CHANNEL_G_BIT|VK_CHANNEL_B_BIT|VK_CHANNEL_A_BIT, // VkChannelFlags channelWriteMask;
+ };
+ const VkPipelineColorBlendStateCreateInfo blendParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ DE_FALSE, // VkBool32 alphaToCoverageEnable;
+ DE_FALSE, // VkBool32 logicOpEnable;
+ VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
+ 1u, // deUint32 attachmentCount;
+ &attBlendParams, // const VkPipelineColorBlendAttachmentState* pAttachments;
};
const VkGraphicsPipelineCreateInfo pipelineParams =
{
- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
- &vertexInputInfo, // const void* pNext;
- 0u, // VkPipelineCreateFlags flags;
- *pipelineLayout // VkPipelineLayout layout;
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (deUint32)DE_LENGTH_OF_ARRAY(shaderStageParams), // deUint32 stageCount;
+ shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
+ &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+ &inputAssemblyParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
+ &viewportParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
+ &rasterParams, // const VkPipelineRasterStateCreateInfo* pRasterState;
+ &multisampleParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
+ &depthStencilParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ &blendParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ 0u, // VkPipelineCreateFlags flags;
+ *pipelineLayout, // VkPipelineLayout layout;
+ DE_NULL, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
+ DE_NULL, // VkPipeline basePipelineHandle;
+ 0u, // deInt32 basePipelineIndex;
};
- const Unique<VkPipelineT> pipeline (createGraphicsPipeline(vk, vkDevice, &pipelineParams));
+ const Unique<VkPipeline> pipeline (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
// Framebuffer
- const VkColorAttachmentBindInfo colorBinding0 =
+ const VkAttachmentBindInfo colorBinding0 =
{
*colorAttView, // VkColorAttachmentView view;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout layout;
{
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 1u, // deUint32 colorAttachmentCount;
- &colorBinding0, // const VkColorAttachmentBindInfo* pColorAttachments;
- DE_NULL, // const VkDepthStencilBindInfo* pDepthStencilAttachment;
- 1u, // deUint32 sampleCount;
+ *renderPass, // VkRenderPass renderPass;
+ 1u, // deUint32 attachmentCount;
+ &colorBinding0, // const VkAttachmentBindInfo* pAttachments;
(deUint32)renderSize.x(), // deUint32 width;
(deUint32)renderSize.y(), // deUint32 height;
1u, // deUint32 layers;
};
- const Unique<VkFramebufferT> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
+ const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
// Viewport state
const VkViewport viewport0 =
0.0f, // float minDepth;
1.0f, // float maxDepth;
};
- const VkRect scissor0 =
+ const VkRect2D scissor0 =
{
{
0u, // deInt32 x;
renderSize.y(), // deInt32 height;
}, // VkExtent2D extent;
};
- const VkDynamicVpStateCreateInfo viewportStateParams =
+ const VkDynamicViewportStateCreateInfo viewportStateParams =
{
- VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
1u, // deUint32 viewportAndScissorCount;
&viewport0, // const VkViewport* pViewports;
&scissor0, // const VkRect* pScissors;
};
- const Unique<VkDynamicVpStateT> viewportState (createDynamicViewportState(vk, vkDevice, &viewportStateParams));
-
- // Render pass
- struct
- {
- VkFormat format;
- VkImageLayout layout;
- VkAttachmentLoadOp loadOp;
- VkAttachmentStoreOp storeOp;
- VkClearColor clearColor;
- } passAttParams =
- {
- VK_FORMAT_R8G8B8A8_UNORM,
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
- VK_ATTACHMENT_LOAD_OP_CLEAR,
- VK_ATTACHMENT_STORE_OP_STORE,
- {
- VkClearColorValue(0.125f, 0.25f, 0.75f, 1.0f),
- DE_FALSE
- },
- };
- const VkRenderPassCreateInfo renderPassParams =
- {
- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- { { 0u, 0u, }, { renderSize.x(), renderSize.y() } }, // VkRect renderArea;
- 1u, // deUint32 colorAttachmentCount;
- { renderSize.x(), renderSize.y() }, // VkExtent2D extent;
- 1u, // deUint32 sampleCount;
- 1u, // deUint32 layers;
- &passAttParams.format, // const VkFormat* pColorFormats;
- &passAttParams.layout, // const VkImageLayout* pColorLayouts;
- &passAttParams.loadOp, // const VkAttachmentLoadOp* pColorLoadOps;
- &passAttParams.storeOp, // const VkAttachmentStoreOp* pColorStoreOps;
- &passAttParams.clearColor, // const VkClearColor* pColorLoadClearValues;
- VK_FORMAT_UNDEFINED, // VkFormat depthStencilFormat;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout depthStencilLayout;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp depthLoadOp;
- 0.0f, // float depthLoadClearValue;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp depthStoreOp;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
- 0u, // deUint32 stencilLoadClearValue;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- };
- const Unique<VkRenderPassT> renderPass (createRenderPass(vk, vkDevice, &renderPassParams));
+ const Unique<VkDynamicViewportState> viewportState (createDynamicViewportState(vk, vkDevice, &viewportStateParams));
// Command buffer
const VkCmdBufferCreateInfo cmdBufParams =
{
VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- context.getUniversalQueueIndex(), // deUint32 queueNodeIndex;
+ DE_NULL, // VkCmdPool pool;
+ VK_CMD_BUFFER_LEVEL_PRIMARY, // VkCmdBufferLevel level;
0u, // VkCmdBufferCreateFlags flags;
};
- const Unique<VkCmdBufferT> cmdBuf (createCommandBuffer(vk, vkDevice, &cmdBufParams));
+ const Unique<VkCmdBuffer> cmdBuf (createCommandBuffer(vk, vkDevice, &cmdBufParams));
const VkCmdBufferBeginInfo cmdBufBeginParams =
{
VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
+ *renderPass, // VkRenderPass renderPass;
+ *framebuffer, // VkFramebuffer framebuffer;
};
// Attach memory
// \note [pyry] Should be able to do this after creating CmdBuffer but one driver crashes at vkCopyImageToBuffer if memory is not attached at that point
- for (size_t allocNdx = 0; allocNdx < vertexBufferAllocs.size(); allocNdx++)
- {
- const VkDeviceMemory memory = vertexBufferAllocs[allocNdx]->getMemory();
- VK_CHECK(vk.queueBindObjectMemory(queue, VK_OBJECT_TYPE_BUFFER, *vertexBuffer, (deUint32)allocNdx, memory, vertexBufferAllocs[allocNdx]->getOffset()));
- VK_CHECK(vk.queueAddMemReferences(queue, 1u, &memory));
- }
-
- for (size_t allocNdx = 0; allocNdx < readImageBufferAllocs.size(); allocNdx++)
- {
- const VkDeviceMemory memory = readImageBufferAllocs[allocNdx]->getMemory();
- VK_CHECK(vk.queueBindObjectMemory(queue, VK_OBJECT_TYPE_BUFFER, *readImageBuffer, (deUint32)allocNdx, memory, readImageBufferAllocs[allocNdx]->getOffset()));
- VK_CHECK(vk.queueAddMemReferences(queue, 1u, &memory));
- }
-
- for (size_t allocNdx = 0; allocNdx < imageAllocs.size(); allocNdx++)
- {
- const VkDeviceMemory memory = imageAllocs[allocNdx]->getMemory();
- VK_CHECK(vk.queueBindObjectMemory(queue, VK_OBJECT_TYPE_IMAGE, *image, (deUint32)allocNdx, memory, imageAllocs[allocNdx]->getOffset()));
- VK_CHECK(vk.queueAddMemReferences(queue, 1u, &memory));
- }
-
- // \note Only buffers and images are expected to require device memory. Later API revisions make this explicit.
- TCU_CHECK(getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, pipeline).empty());
- TCU_CHECK(getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, framebuffer).empty());
- TCU_CHECK(getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, viewportState).empty());
- TCU_CHECK(getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, renderPass).empty());
- TCU_CHECK(getObjectInfo<VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS>(vk, vkDevice, cmdBuf).empty());
+ VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
+ VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
+ VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
// Record commands
VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginParams));
{
- const VkPipeEvent pipeEvent = VK_PIPE_EVENT_TOP_OF_PIPE;
const VkMemoryBarrier vertFlushBarrier =
{
VK_STRUCTURE_TYPE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
- VK_MEMORY_OUTPUT_CPU_WRITE_BIT, // VkMemoryOutputFlags outputMask;
+ VK_MEMORY_OUTPUT_HOST_WRITE_BIT, // VkMemoryOutputFlags outputMask;
VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT, // VkMemoryInputFlags inputMask;
};
const VkImageMemoryBarrier colorAttBarrier =
0u, // VkMemoryInputFlags inputMask;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
+ queueIndex, // deUint32 srcQueueFamilyIndex;
+ queueIndex, // deUint32 destQueueFamilyIndex;
*image, // VkImage image;
{
VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
} // VkImageSubresourceRange subresourceRange;
};
const void* barriers[] = { &vertFlushBarrier, &colorAttBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_WAIT_EVENT_TOP_OF_PIPE, 1u, &pipeEvent, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
}
{
- const VkRenderPassBegin passBeginParams =
+ const VkClearValue clearValue = clearValueColorF32(0.125f, 0.25f, 0.75f, 1.0f);
+ const VkRenderPassBeginInfo passBeginParams =
{
- *renderPass, // VkRenderPass renderPass;
- *framebuffer, // VkFramebuffer framebuffer;
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *renderPass, // VkRenderPass renderPass;
+ *framebuffer, // VkFramebuffer framebuffer;
+ { { 0, 0 }, { renderSize.x(), renderSize.y() } }, // VkRect2D renderArea;
+ 1u, // deUint32 attachmentCount;
+ &clearValue, // const VkClearValue* pAttachmentClearValues;
};
- vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams);
+ vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_RENDER_PASS_CONTENTS_INLINE);
}
- vk.cmdBindDynamicStateObject(*cmdBuf, VK_STATE_BIND_POINT_VIEWPORT, *viewportState);
+ vk.cmdBindDynamicViewportState(*cmdBuf, *viewportState);
vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
{
const VkDeviceSize bindingOffset = 0;
vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
}
vk.cmdDraw(*cmdBuf, 0u, 3u, 0u, 1u);
- vk.cmdEndRenderPass(*cmdBuf, *renderPass);
+ vk.cmdEndRenderPass(*cmdBuf);
{
- const VkPipeEvent pipeEvent = VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE;
const VkImageMemoryBarrier renderFinishBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
VK_MEMORY_INPUT_TRANSFER_BIT, // VkMemoryInputFlags inputMask;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, // VkImageLayout newLayout;
+ queueIndex, // deUint32 srcQueueFamilyIndex;
+ queueIndex, // deUint32 destQueueFamilyIndex;
*image, // VkImage image;
{
VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
} // VkImageSubresourceRange subresourceRange;
};
const void* barriers[] = { &renderFinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_WAIT_EVENT_TOP_OF_PIPE, 1u, &pipeEvent, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
}
{
const VkBufferImageCopy copyParams =
{
(VkDeviceSize)0u, // VkDeviceSize bufferOffset;
+ (deUint32)(renderSize.x()*4), // deUint32 bufferRowLength;
+ 0u, // deUint32 bufferImageHeight;
{
VK_IMAGE_ASPECT_COLOR, // VkImageAspect aspect;
0u, // deUint32 mipLevel;
}
{
- const VkPipeEvent pipeEvent = VK_PIPE_EVENT_TRANSFER_COMPLETE;
const VkBufferMemoryBarrier copyFinishBarrier =
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_MEMORY_OUTPUT_TRANSFER_BIT, // VkMemoryOutputFlags outputMask;
- VK_MEMORY_INPUT_CPU_READ_BIT, // VkMemoryInputFlags inputMask;
+ VK_MEMORY_INPUT_HOST_READ_BIT, // VkMemoryInputFlags inputMask;
+ queueIndex, // deUint32 srcQueueFamilyIndex;
+ queueIndex, // deUint32 destQueueFamilyIndex;
*readImageBuffer, // VkBuffer buffer;
0u, // VkDeviceSize offset;
imageSizeBytes // VkDeviceSize size;
};
const void* barriers[] = { ©FinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_WAIT_EVENT_TOP_OF_PIPE, 1u, &pipeEvent, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
}
VK_CHECK(vk.endCommandBuffer(*cmdBuf));
// Upload vertex data
{
+ const VkMappedMemoryRange range =
+ {
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ vertexBufferMemory->getMemory(), // VkDeviceMemory mem;
+ 0, // VkDeviceSize offset;
+ (VkDeviceSize)sizeof(vertices), // VkDeviceSize size;
+ };
void* vertexBufPtr = DE_NULL;
- VK_CHECK(vk.mapMemory(vkDevice, vertexBufferAllocs[0]->getMemory(), vertexBufferAllocs[0]->getOffset(), (VkDeviceSize)sizeof(vertices), 0u, &vertexBufPtr));
+ VK_CHECK(vk.mapMemory(vkDevice, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset(), (VkDeviceSize)sizeof(vertices), 0u, &vertexBufPtr));
deMemcpy(vertexBufPtr, &vertices[0], sizeof(vertices));
- VK_CHECK(vk.flushMappedMemory(vkDevice, vertexBufferAllocs[0]->getMemory(), vertexBufferAllocs[0]->getOffset(), (VkDeviceSize)sizeof(vertices)));
- VK_CHECK(vk.unmapMemory(vkDevice, vertexBufferAllocs[0]->getMemory()));
+ VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &range));
+ VK_CHECK(vk.unmapMemory(vkDevice, vertexBufferMemory->getMemory()));
}
// Submit & wait for completion
DE_NULL, // const void* pNext;
0u, // VkFenceCreateFlags flags;
};
- const Unique<VkFenceT> fence (createFence(vk, vkDevice, &fenceParams));
+ const Unique<VkFence> fence (createFence(vk, vkDevice, &fenceParams));
VK_CHECK(vk.queueSubmit(queue, 1u, &cmdBuf.get(), *fence));
VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
{
void* imagePtr = DE_NULL;
- VK_CHECK(vk.mapMemory(vkDevice, readImageBufferAllocs[0]->getMemory(), readImageBufferAllocs[0]->getOffset(), imageSizeBytes, 0u, &imagePtr));
+ VK_CHECK(vk.mapMemory(vkDevice, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset(), imageSizeBytes, 0u, &imagePtr));
context.getTestContext().getLog() << TestLog::Image("Result", "Result", tcu::ConstPixelBufferAccess(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), renderSize.x(), renderSize.y(), 1, imagePtr));
- VK_CHECK(vk.unmapMemory(vkDevice, readImageBufferAllocs[0]->getMemory()));
+ VK_CHECK(vk.unmapMemory(vkDevice, readImageBufferMemory->getMemory()));
}
return tcu::TestStatus::pass("Rendering succeeded");
{
de::MovePtr<tcu::TestCaseGroup> apiTests (new tcu::TestCaseGroup(testCtx, "api", "API Tests"));
- addFunctionCase (apiTests.get(), "create_sampler", "", createSampler);
- addFunctionCaseWithPrograms (apiTests.get(), "create_shader", "", createShaderProgs, createShader);
- addFunctionCaseWithPrograms (apiTests.get(), "triangle", "", createTriangleProgs, renderTriangle);
+ addFunctionCase (apiTests.get(), "create_sampler", "", createSamplerTest);
+ addFunctionCaseWithPrograms (apiTests.get(), "create_shader", "", createShaderProgs, createShaderModuleTest);
+ addFunctionCaseWithPrograms (apiTests.get(), "triangle", "", createTriangleProgs, renderTriangleTest);
return apiTests.release();
}
#include "tcuFormatUtil.hpp"
#include "deUniquePtr.hpp"
-#include "deStringUtil.hpp"
namespace vkt
{
tcu::TestStatus enumeratePhysicalDevices (Context& context)
{
- const PlatformInterface& vkPlatform = context.getPlatformInterface();
- TestLog& log = context.getTestContext().getLog();
- const VkInstance instance = context.getInstance();
- const vector<VkPhysicalDevice> devices = vk::enumeratePhysicalDevices(vkPlatform, instance);
+ TestLog& log = context.getTestContext().getLog();
+ const vector<VkPhysicalDevice> devices = vk::enumeratePhysicalDevices(context.getInstanceInterface(), context.getInstance());
log << TestLog::Integer("NumDevices", "Number of devices", "", QP_KEY_TAG_NONE, deInt64(devices.size()));
for (size_t ndx = 0; ndx < devices.size(); ndx++)
- log << TestLog::Message << ndx << ": " << tcu::toHex(devices[ndx]) << TestLog::EndMessage;
+ log << TestLog::Message << ndx << ": " << devices[ndx] << TestLog::EndMessage;
return tcu::TestStatus::pass("Enumerating devices succeeded");
}
-template<VkPhysicalDeviceInfoType InfoType>
-tcu::TestStatus singleProperty (Context& context)
+tcu::TestStatus queueProperties (Context& context)
{
- const PlatformInterface& vkPlatform = context.getPlatformInterface();
- TestLog& log = context.getTestContext().getLog();
- const VkInstance instance = context.getInstance();
- const vector<VkPhysicalDevice> devices = vk::enumeratePhysicalDevices(vkPlatform, instance);
+ TestLog& log = context.getTestContext().getLog();
+ const vector<VkPhysicalDeviceQueueProperties> queueProperties = getPhysicalDeviceQueueProperties(context.getInstanceInterface(), context.getPhysicalDevice());
- for (size_t ndx = 0; ndx < devices.size(); ndx++)
- {
- const VkPhysicalDevice physicalDevice = devices[ndx];
- const tcu::ScopedLogSection section (log, string("Device") + de::toString(ndx), string("Device ") + de::toString(ndx) + " (" + de::toString(tcu::toHex(physicalDevice)) + ")");
- const vk::DeviceDriver vkDevice (vkPlatform, physicalDevice);
+ log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage;
- log << TestLog::Message << getPhysicalDeviceInfo<InfoType>(vkDevice, physicalDevice) << TestLog::EndMessage;
- }
+ for (size_t queueNdx = 0; queueNdx < queueProperties.size(); queueNdx++)
+ log << TestLog::Message << queueNdx << ": " << queueProperties[queueNdx] << TestLog::EndMessage;
- return tcu::TestStatus::pass("Querying properties succeeded");
+ return tcu::TestStatus::pass("Querying queue properties succeeded");
}
-template<VkPhysicalDeviceInfoType InfoType>
-tcu::TestStatus multiProperty (Context& context, const char* propName)
+tcu::TestStatus memoryProperties (Context& context)
{
- typedef typename vk::querydetails::PhysicalDeviceInfoTraits<InfoType>::Type PropertyType;
-
- const PlatformInterface& vkPlatform = context.getPlatformInterface();
- TestLog& log = context.getTestContext().getLog();
- const VkInstance instance = context.getInstance();
- const vector<VkPhysicalDevice> devices = vk::enumeratePhysicalDevices(vkPlatform, instance);
-
- for (size_t deviceNdx = 0; deviceNdx < devices.size(); deviceNdx++)
- {
- const VkPhysicalDevice physicalDevice = devices[deviceNdx];
- const tcu::ScopedLogSection deviceSection (log, string("Device") + de::toString(deviceNdx), string("Device ") + de::toString(deviceNdx) + " (" + de::toString(tcu::toHex(physicalDevice)) + ")");
- const vk::DeviceDriver vkDevice (vkPlatform, physicalDevice);
- const vector<PropertyType> properties = getPhysicalDeviceInfo<InfoType>(vkDevice, physicalDevice);
+ TestLog& log = context.getTestContext().getLog();
- log << TestLog::Integer(string("Num") + propName + "Props", string("Number of ") + propName + " properties", "", QP_KEY_TAG_NONE, (deInt64)properties.size());
+ log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage;
- for (size_t entryNdx = 0; entryNdx < properties.size(); entryNdx++)
- log << TestLog::Message << properties[entryNdx] << TestLog::EndMessage;
- }
+ log << TestLog::Message
+ << getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())
+ << TestLog::EndMessage;
- return tcu::TestStatus::pass("Querying properties succeeded");
+ return tcu::TestStatus::pass("Querying memory properties succeeded");
}
} // anonymous
de::MovePtr<tcu::TestCaseGroup> infoTests (new tcu::TestCaseGroup(testCtx, "info", "Platform Information Tests"));
addFunctionCase(infoTests.get(), "physical_devices", "Physical devices", enumeratePhysicalDevices);
- addFunctionCase(infoTests.get(), "device_properties", "Device properties", singleProperty<VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES>);
- addFunctionCase(infoTests.get(), "performance", "Performance", singleProperty<VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE>);
- addFunctionCase(infoTests.get(), "queue_properties", "Queue properties", multiProperty<VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES>, "Queue");
- addFunctionCase(infoTests.get(), "memory_properties", "Memory properties", multiProperty<VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES>, "Memory");
+ addFunctionCase(infoTests.get(), "queue_properties", "Queue properties", queueProperties);
+ addFunctionCase(infoTests.get(), "memory_properties", "Memory properties", memoryProperties);
return infoTests.release();
}
using std::vector;
using namespace vk;
-static deUint32 findQueueNodeIndexWithCaps (const DeviceInterface& vkDevice, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
+static deUint32 findQueueNodeIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
{
- const vector<VkPhysicalDeviceQueueProperties> queueProps = getPhysicalDeviceInfo<VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES>(vkDevice, physicalDevice);
+ const vector<VkPhysicalDeviceQueueProperties> queueProps = getPhysicalDeviceQueueProperties(vkInstance, physicalDevice);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
{
struct DeviceCreateInfoHelper
{
+ VkPhysicalDeviceFeatures enabledFeatures;
VkDeviceQueueCreateInfo queueInfo;
VkDeviceCreateInfo deviceInfo;
DeviceCreateInfoHelper (deUint32 queueIndex)
{
- deMemset(&queueInfo, 0, sizeof(queueInfo));
- deMemset(&deviceInfo, 0, sizeof(deviceInfo));
+ deMemset(&enabledFeatures, 0, sizeof(enabledFeatures));
+ deMemset(&queueInfo, 0, sizeof(queueInfo));
+ deMemset(&deviceInfo, 0, sizeof(deviceInfo));
- queueInfo.queueNodeIndex = queueIndex;
+ // \todo [2015-07-09 pyry] What's the policy for enabling features?
+ // * Enable all supported by default, and expose that to test cases
+ // * More limited enabled set could be used for verifying that tests behave correctly
+
+ queueInfo.queueFamilyIndex = queueIndex;
queueInfo.queueCount = 1u;
deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceInfo.pRequestedQueues = &queueInfo;
deviceInfo.extensionCount = 0u;
deviceInfo.ppEnabledExtensionNames = DE_NULL;
+ deviceInfo.pEnabledFeatures = &enabledFeatures;
deviceInfo.flags = 0u;
}
};
~DefaultDevice (void);
VkInstance getInstance (void) const { return *m_instance; }
+ const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
+
VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
+
VkDevice getDevice (void) const { return *m_device; }
- const DeviceInterface& getInterface (void) const { return m_deviceInterface; }
+ const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
+
deUint32 getUniversalQueueIndex (void) const { return m_universalQueueIndex; }
VkQueue getUniversalQueue (void) const;
private:
- const Unique<VkInstanceT> m_instance;
+ const Unique<VkInstance> m_instance;
+ const InstanceDriver m_instanceInterface;
+
const VkPhysicalDevice m_physicalDevice;
- const DeviceDriver m_deviceInterface;
+
const deUint32 m_universalQueueIndex;
const DeviceCreateInfoHelper m_deviceCreateInfo;
- const Unique<VkDeviceT> m_device;
+
+ const Unique<VkDevice> m_device;
+ const DeviceDriver m_deviceInterface;
};
DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
: m_instance (createDefaultInstance(vkPlatform))
- , m_physicalDevice (chooseDevice(vkPlatform, *m_instance, cmdLine))
- , m_deviceInterface (vkPlatform, m_physicalDevice)
- , m_universalQueueIndex (findQueueNodeIndexWithCaps(m_deviceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT|VK_QUEUE_DMA_BIT|VK_QUEUE_MEMMGR_BIT))
+ , m_instanceInterface (vkPlatform, *m_instance)
+ , m_physicalDevice (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
+ , m_universalQueueIndex (findQueueNodeIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT|VK_QUEUE_DMA_BIT))
, m_deviceCreateInfo (m_universalQueueIndex)
- , m_device (createDevice(m_deviceInterface, m_physicalDevice, &m_deviceCreateInfo.deviceInfo))
+ , m_device (createDevice(m_instanceInterface, m_physicalDevice, &m_deviceCreateInfo.deviceInfo))
+ , m_deviceInterface (m_instanceInterface, *m_device)
{
}
delete m_device;
}
-vk::VkInstance Context::getInstance (void) const { return m_device->getInstance(); }
-vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
-vk::VkDevice Context::getDevice (void) const { return m_device->getDevice(); }
-const vk::DeviceInterface& Context::getDeviceInterface (void) const { return m_device->getInterface(); }
-deUint32 Context::getUniversalQueueIndex (void) const { return m_device->getUniversalQueueIndex(); }
-vk::VkQueue Context::getUniversalQueue (void) const { return m_device->getUniversalQueue(); }
+vk::VkInstance Context::getInstance (void) const { return m_device->getInstance(); }
+const vk::InstanceInterface& Context::getInstanceInterface (void) const { return m_device->getInstanceInterface(); }
+vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
+vk::VkDevice Context::getDevice (void) const { return m_device->getDevice(); }
+const vk::DeviceInterface& Context::getDeviceInterface (void) const { return m_device->getDeviceInterface(); }
+deUint32 Context::getUniversalQueueIndex (void) const { return m_device->getUniversalQueueIndex(); }
+vk::VkQueue Context::getUniversalQueue (void) const { return m_device->getUniversalQueue(); }
// TestCase
// Default instance & device, selected with --deqp-vk-device-id=N
vk::VkInstance getInstance (void) const;
+ const vk::InstanceInterface& getInstanceInterface (void) const;
vk::VkPhysicalDevice getPhysicalDevice (void) const;
vk::VkDevice getDevice (void) const;
const vk::DeviceInterface& getDeviceInterface (void) const;
#include "egluUtil.hpp"
#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"
+#include "tcuFunctionLibrary.hpp"
// Assume no call translation is needed
#include <android/native_window.h>
// Vulkan
-static vk::GetProcAddrFunc loadGetProcAddr (const de::DynamicLibrary& library)
-{
- const vk::GetProcAddrFunc getProc = (vk::GetProcAddrFunc)library.getFunction("vkGetProcAddr");
-
- if (!getProc)
- TCU_THROW(InternalError, "Failed to load vkGetProcAddr");
-
- return getProc;
-}
-
class VulkanLibrary : public vk::Library
{
public:
VulkanLibrary (void)
: m_library ("libvulkan.so")
- , m_driver (loadGetProcAddr(m_library))
+ , m_driver (m_library)
{
}
}
private:
- const de::DynamicLibrary m_library;
- const vk::PlatformDriver m_driver;
+ const tcu::DynamicFunctionLibrary m_library;
+ const vk::PlatformDriver m_driver;
};
// Platform
#include "tcuWin32Platform.hpp"
#include "tcuWGLContextFactory.hpp"
+#include "tcuFunctionLibrary.hpp"
#if defined(DEQP_SUPPORT_EGL)
# include "tcuWin32EGLNativeDisplayFactory.hpp"
namespace tcu
{
-static vk::GetProcAddrFunc loadGetProcAddr (const de::DynamicLibrary& library)
-{
- const vk::GetProcAddrFunc getProc = (vk::GetProcAddrFunc)library.getFunction("vkGetProcAddr");
-
- if (!getProc)
- TCU_THROW(InternalError, "Failed to load vkGetProcAddr");
-
- return getProc;
-}
-
class VulkanLibrary : public vk::Library
{
public:
VulkanLibrary (void)
: m_library ("vulkan.dll")
- , m_driver (loadGetProcAddr(m_library))
+ , m_driver (m_library)
{
}
}
private:
- const de::DynamicLibrary m_library;
- const vk::PlatformDriver m_driver;
+ const tcu::DynamicFunctionLibrary m_library;
+ const vk::PlatformDriver m_driver;
};
Win32Platform::Win32Platform (void)
projects / platform / upstream / VK-GL-CTS.git / commitdiff