enum VkResult
{
-- VK_SUCCESS = 0,
-- VK_NOT_READY = 1,
-- VK_TIMEOUT = 2,
-- VK_EVENT_SET = 3,
-- VK_EVENT_RESET = 4,
-- VK_INCOMPLETE = 5,
-- VK_ERROR_OUT_OF_HOST_MEMORY = -1,
-- VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
-- VK_ERROR_INITIALIZATION_FAILED = -3,
-- VK_ERROR_DEVICE_LOST = -4,
-- VK_ERROR_MEMORY_MAP_FAILED = -5,
-- VK_ERROR_LAYER_NOT_PRESENT = -6,
-- VK_ERROR_EXTENSION_NOT_PRESENT = -7,
-- VK_ERROR_FEATURE_NOT_PRESENT = -8,
-- VK_ERROR_INCOMPATIBLE_DRIVER = -9,
-- VK_ERROR_TOO_MANY_OBJECTS = -10,
-- VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
-- VK_ERROR_FRAGMENTED_POOL = -12,
-- VK_ERROR_SURFACE_LOST_KHR = -1000000000,
-- VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
-- VK_SUBOPTIMAL_KHR = 1000001003,
-- VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
-- VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
-- VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
-- VK_ERROR_INVALID_SHADER_NV = -1000012000,
-- VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
++ VK_SUCCESS = 0,
++ VK_NOT_READY = 1,
++ VK_TIMEOUT = 2,
++ VK_EVENT_SET = 3,
++ VK_EVENT_RESET = 4,
++ VK_INCOMPLETE = 5,
++ VK_ERROR_OUT_OF_HOST_MEMORY = -1,
++ VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
++ VK_ERROR_INITIALIZATION_FAILED = -3,
++ VK_ERROR_DEVICE_LOST = -4,
++ VK_ERROR_MEMORY_MAP_FAILED = -5,
++ VK_ERROR_LAYER_NOT_PRESENT = -6,
++ VK_ERROR_EXTENSION_NOT_PRESENT = -7,
++ VK_ERROR_FEATURE_NOT_PRESENT = -8,
++ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
++ VK_ERROR_TOO_MANY_OBJECTS = -10,
++ VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
++ VK_ERROR_FRAGMENTED_POOL = -12,
++ VK_ERROR_SURFACE_LOST_KHR = -1000000000,
++ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
++ VK_SUBOPTIMAL_KHR = 1000001003,
++ VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
++ VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
++ VK_ERROR_INVALID_SHADER_NV = -1000012000,
++ VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
++ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003,
};
enum VkStructureType
{
- VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
- VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
- VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
- VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
- VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
- VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
- VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
- VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
- VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
- VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
- VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
- VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
- VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
- VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
- VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
- VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
- VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
- VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
- VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
- VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
- VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
- VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
- VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
- VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
- VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
- VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
- VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
- VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
- VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
- VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
- VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
- VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
- VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
- VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
- VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
- VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
- VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
- VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
- VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
- VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
- VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
- VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
- VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
- VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
- VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
- VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
- VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
- VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
- VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
- VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000,
- VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002,
- VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004,
- VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000,
- VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001,
- VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002,
- VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000,
- VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001,
- VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000,
- VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000,
- VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001,
- VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000,
- VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000,
- VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001,
- VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002,
- VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
- VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
- VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
- VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
- VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
- VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
- VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
- VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
- VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
- VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
+ VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
+ VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
+ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
+ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
+ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
+ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
+ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
+ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
+ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
+ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
+ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
+ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
+ VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
+ VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+ VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+ VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
+ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
+ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+ VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
++ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
+ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
+ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
+ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
+ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000,
++ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002,
++ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004,
++ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000,
++ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001,
++ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002,
++ VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000,
++ VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001,
++ VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002,
++ VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000,
++ VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000,
++ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001,
++ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000,
++ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000,
++ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001,
++ VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002,
++ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
++ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
+ VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
+ VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
+ VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
+ VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
+ VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
};
enum VkSystemAllocationScope
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
++ VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
};
typedef deUint32 VkImageCreateFlags;
enum VkMemoryHeapFlagBits
{
-- VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
++ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
++ VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
};
typedef deUint32 VkMemoryHeapFlags;
enum VkPipelineCreateFlagBits
{
- VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
- VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
- VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
++ VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
};
typedef deUint32 VkPipelineCreateFlags;
enum VkDependencyFlagBits
{
- VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+ VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+ VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
++ VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
};
typedef deUint32 VkDependencyFlags;
};
typedef deUint32 VkCompositeAlphaFlagsKHR;
++enum VkSwapchainCreateFlagBitsKHR
++{
++ VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
++};
+ typedef deUint32 VkSwapchainCreateFlagsKHR;
+
enum VkDisplayPlaneAlphaFlagBitsKHR
{
VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
};
typedef deUint32 VkDebugReportFlagsEXT;
- enum VkExternalMemoryHandleTypeFlagBitsNV
- {
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
- };
- typedef deUint32 VkExternalMemoryHandleTypeFlagsNV;
-
- enum VkExternalMemoryFeatureFlagBitsNV
- {
- VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
- VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
- VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
- };
- typedef deUint32 VkExternalMemoryFeatureFlagsNV;
-
+enum VkExternalMemoryHandleTypeFlagBitsKHX
+{
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 0x00000008,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040,
+};
+typedef deUint32 VkExternalMemoryHandleTypeFlagsKHX;
+
+enum VkExternalMemoryFeatureFlagBitsKHX
+{
+ VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 0x00000004,
+};
+typedef deUint32 VkExternalMemoryFeatureFlagsKHX;
+
+enum VkExternalSemaphoreHandleTypeFlagBitsKHX
+{
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010,
+};
+typedef deUint32 VkExternalSemaphoreHandleTypeFlagsKHX;
+
+enum VkExternalSemaphoreFeatureFlagBitsKHX
+{
+ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 0x00000002,
+};
+typedef deUint32 VkExternalSemaphoreFeatureFlagsKHX;
+
- enum VkIndirectCommandsLayoutUsageFlagBitsNVX
- {
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
- };
- typedef deUint32 VkIndirectCommandsLayoutUsageFlagsNVX;
-
- enum VkObjectEntryUsageFlagBitsNVX
- {
- VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
- VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
- };
- typedef deUint32 VkObjectEntryUsageFlagsNVX;
-
typedef deUint32 VkInstanceCreateFlags;
typedef deUint32 VkDeviceCreateFlags;
virtual VkResult queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const;
virtual VkResult createSharedSwapchainsKHR (VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const;
virtual void trimCommandPoolKHR (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) const;
+ virtual void cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const;
+ virtual VkResult createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const;
+ virtual void destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const;
+ virtual void updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const;
+ virtual void cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const;
virtual VkResult getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const;
- virtual VkResult debugMarkerSetObjectTagEXT (VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo) const;
- virtual VkResult debugMarkerSetObjectNameEXT (VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo) const;
- virtual void cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const;
- virtual void cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer) const;
- virtual void cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const;
- virtual void cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
- virtual void cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
- virtual VkResult getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const;
+virtual VkResult getMemoryWin32HandleKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const;
++virtual VkResult getMemoryWin32HandlePropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties) const;
+virtual VkResult getMemoryFdKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd) const;
++virtual VkResult getMemoryFdPropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties) const;
+virtual VkResult importSemaphoreWin32HandleKHX (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo) const;
+virtual VkResult getSemaphoreWin32HandleKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const;
+virtual VkResult importSemaphoreFdKHX (VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo) const;
+virtual VkResult getSemaphoreFdKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd) const;
- virtual void cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const;
- virtual void cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) const;
- virtual VkResult createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) const;
- virtual void destroyIndirectCommandsLayoutNVX (VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const;
- virtual VkResult createObjectTableNVX (VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) const;
- virtual void destroyObjectTableNVX (VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) const;
- virtual VkResult registerObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices) const;
- virtual VkResult unregisterObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices) const;
- virtual void cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const;
- virtual VkResult createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const;
- virtual void destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const;
- virtual void updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const;
- virtual void cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const;
virtual VkResult getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const;
virtual VkResult getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, deUint32* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const;
virtual VkResult createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const;
virtual void destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const;
virtual void debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage) const;
- virtual VkResult getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const;
+virtual void getPhysicalDeviceExternalBufferPropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties) const;
+virtual void getPhysicalDeviceExternalSemaphorePropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties) const;
- virtual void getPhysicalDeviceGeneratedCommandsPropertiesNVX (VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) const;
m_vk.trimCommandPoolKHR(device, commandPool, flags);
}
- VkResult DeviceDriver::getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const
- {
- return m_vk.getSwapchainStatusKHR(device, swapchain);
- }
-
- VkResult DeviceDriver::debugMarkerSetObjectTagEXT (VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo) const
+ void DeviceDriver::cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const
{
- return m_vk.debugMarkerSetObjectTagEXT(device, pTagInfo);
+ m_vk.cmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
}
- VkResult DeviceDriver::debugMarkerSetObjectNameEXT (VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo) const
+ VkResult DeviceDriver::createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const
{
- return m_vk.debugMarkerSetObjectNameEXT(device, pNameInfo);
+ return m_vk.createDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
}
- void DeviceDriver::cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const
+ void DeviceDriver::destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const
{
- m_vk.cmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
+ m_vk.destroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
}
- void DeviceDriver::cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer) const
+ void DeviceDriver::updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const
{
- m_vk.cmdDebugMarkerEndEXT(commandBuffer);
+ m_vk.updateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
}
- void DeviceDriver::cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const
+ void DeviceDriver::cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const
{
- m_vk.cmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
+ m_vk.cmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}
- void DeviceDriver::cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
+ VkResult DeviceDriver::getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const
{
- m_vk.cmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+ return m_vk.getSwapchainStatusKHR(device, swapchain);
}
- void DeviceDriver::cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
++VkResult DeviceDriver::getMemoryWin32HandleKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const
+{
- m_vk.cmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
++ return m_vk.getMemoryWin32HandleKHX(device, memory, handleType, pHandle);
+}
+
- VkResult DeviceDriver::getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const
++VkResult DeviceDriver::getMemoryWin32HandlePropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties) const
+{
- return m_vk.getMemoryWin32HandleNV(device, memory, handleType, pHandle);
++ return m_vk.getMemoryWin32HandlePropertiesKHX(device, handleType, handle, pMemoryWin32HandleProperties);
+}
+
- VkResult DeviceDriver::getMemoryWin32HandleKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const
++VkResult DeviceDriver::getMemoryFdKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd) const
+{
- return m_vk.getMemoryWin32HandleKHX(device, memory, handleType, pHandle);
++ return m_vk.getMemoryFdKHX(device, memory, handleType, pFd);
+}
+
- VkResult DeviceDriver::getMemoryFdKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd) const
++VkResult DeviceDriver::getMemoryFdPropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties) const
+{
- return m_vk.getMemoryFdKHX(device, memory, handleType, pFd);
++ return m_vk.getMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties);
+}
+
+VkResult DeviceDriver::importSemaphoreWin32HandleKHX (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo) const
+{
+ return m_vk.importSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo);
+}
+
+VkResult DeviceDriver::getSemaphoreWin32HandleKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const
+{
+ return m_vk.getSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle);
+}
+
+VkResult DeviceDriver::importSemaphoreFdKHX (VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo) const
+{
+ return m_vk.importSemaphoreFdKHX(device, pImportSemaphoreFdInfo);
+}
+
+VkResult DeviceDriver::getSemaphoreFdKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd) const
+{
+ return m_vk.getSemaphoreFdKHX(device, semaphore, handleType, pFd);
+}
+
- void DeviceDriver::cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const
- {
- m_vk.cmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
- }
-
- void DeviceDriver::cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) const
- {
- m_vk.cmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
- }
-
- VkResult DeviceDriver::createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) const
- {
- return m_vk.createIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
- }
-
- void DeviceDriver::destroyIndirectCommandsLayoutNVX (VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const
- {
- m_vk.destroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
- }
-
- VkResult DeviceDriver::createObjectTableNVX (VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) const
- {
- return m_vk.createObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
- }
-
- void DeviceDriver::destroyObjectTableNVX (VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) const
- {
- m_vk.destroyObjectTableNVX(device, objectTable, pAllocator);
- }
-
- VkResult DeviceDriver::registerObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices) const
- {
- return m_vk.registerObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
- }
-
- VkResult DeviceDriver::unregisterObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices) const
- {
- return m_vk.unregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
- }
-
- void DeviceDriver::cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const
- {
- m_vk.cmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
- }
-
- VkResult DeviceDriver::createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const
- {
- return m_vk.createDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
- }
-
- void DeviceDriver::destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const
- {
- m_vk.destroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
- }
-
- void DeviceDriver::updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const
- {
- m_vk.updateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
- }
-
- void DeviceDriver::cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const
- {
- m_vk.cmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
- }
-
VkResult DeviceDriver::getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const
{
return m_vk.getRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
QueuePresentKHRFunc queuePresentKHR;
CreateSharedSwapchainsKHRFunc createSharedSwapchainsKHR;
TrimCommandPoolKHRFunc trimCommandPoolKHR;
+ CmdPushDescriptorSetKHRFunc cmdPushDescriptorSetKHR;
+ CreateDescriptorUpdateTemplateKHRFunc createDescriptorUpdateTemplateKHR;
+ DestroyDescriptorUpdateTemplateKHRFunc destroyDescriptorUpdateTemplateKHR;
+ UpdateDescriptorSetWithTemplateKHRFunc updateDescriptorSetWithTemplateKHR;
+ CmdPushDescriptorSetWithTemplateKHRFunc cmdPushDescriptorSetWithTemplateKHR;
GetSwapchainStatusKHRFunc getSwapchainStatusKHR;
- DebugMarkerSetObjectTagEXTFunc debugMarkerSetObjectTagEXT;
- DebugMarkerSetObjectNameEXTFunc debugMarkerSetObjectNameEXT;
- CmdDebugMarkerBeginEXTFunc cmdDebugMarkerBeginEXT;
- CmdDebugMarkerEndEXTFunc cmdDebugMarkerEndEXT;
- CmdDebugMarkerInsertEXTFunc cmdDebugMarkerInsertEXT;
- CmdDrawIndirectCountAMDFunc cmdDrawIndirectCountAMD;
- CmdDrawIndexedIndirectCountAMDFunc cmdDrawIndexedIndirectCountAMD;
- GetMemoryWin32HandleNVFunc getMemoryWin32HandleNV;
+GetMemoryWin32HandleKHXFunc getMemoryWin32HandleKHX;
++GetMemoryWin32HandlePropertiesKHXFunc getMemoryWin32HandlePropertiesKHX;
+GetMemoryFdKHXFunc getMemoryFdKHX;
++GetMemoryFdPropertiesKHXFunc getMemoryFdPropertiesKHX;
+ImportSemaphoreWin32HandleKHXFunc importSemaphoreWin32HandleKHX;
+GetSemaphoreWin32HandleKHXFunc getSemaphoreWin32HandleKHX;
+ImportSemaphoreFdKHXFunc importSemaphoreFdKHX;
+GetSemaphoreFdKHXFunc getSemaphoreFdKHX;
- CmdProcessCommandsNVXFunc cmdProcessCommandsNVX;
- CmdReserveSpaceForCommandsNVXFunc cmdReserveSpaceForCommandsNVX;
- CreateIndirectCommandsLayoutNVXFunc createIndirectCommandsLayoutNVX;
- DestroyIndirectCommandsLayoutNVXFunc destroyIndirectCommandsLayoutNVX;
- CreateObjectTableNVXFunc createObjectTableNVX;
- DestroyObjectTableNVXFunc destroyObjectTableNVX;
- RegisterObjectsNVXFunc registerObjectsNVX;
- UnregisterObjectsNVXFunc unregisterObjectsNVX;
- CmdPushDescriptorSetKHRFunc cmdPushDescriptorSetKHR;
- CreateDescriptorUpdateTemplateKHRFunc createDescriptorUpdateTemplateKHR;
- DestroyDescriptorUpdateTemplateKHRFunc destroyDescriptorUpdateTemplateKHR;
- UpdateDescriptorSetWithTemplateKHRFunc updateDescriptorSetWithTemplateKHR;
- CmdPushDescriptorSetWithTemplateKHRFunc cmdPushDescriptorSetWithTemplateKHR;
GetRefreshCycleDurationGOOGLEFunc getRefreshCycleDurationGOOGLE;
GetPastPresentationTimingGOOGLEFunc getPastPresentationTimingGOOGLE;
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateDebugReportCallbackEXTFunc) (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
typedef VKAPI_ATTR void (VKAPI_CALL* DestroyDebugReportCallbackEXTFunc) (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
typedef VKAPI_ATTR void (VKAPI_CALL* DebugReportMessageEXTFunc) (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* DebugMarkerSetObjectTagEXTFunc) (VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* DebugMarkerSetObjectNameEXTFunc) (VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdDebugMarkerBeginEXTFunc) (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdDebugMarkerEndEXTFunc) (VkCommandBuffer commandBuffer);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdDebugMarkerInsertEXTFunc) (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawIndirectCountAMDFunc) (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawIndexedIndirectCountAMDFunc) (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceExternalImageFormatPropertiesNVFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryWin32HandleNVFunc) (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle);
+typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceExternalBufferPropertiesKHXFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryWin32HandleKHXFunc) (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle);
++typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryWin32HandlePropertiesKHXFunc) (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryFdKHXFunc) (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd);
++typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryFdPropertiesKHXFunc) (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties);
+typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceExternalSemaphorePropertiesKHXFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* ImportSemaphoreWin32HandleKHXFunc) (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetSemaphoreWin32HandleKHXFunc) (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* ImportSemaphoreFdKHXFunc) (VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetSemaphoreFdKHXFunc) (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdProcessCommandsNVXFunc) (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdReserveSpaceForCommandsNVXFunc) (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateIndirectCommandsLayoutNVXFunc) (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
- typedef VKAPI_ATTR void (VKAPI_CALL* DestroyIndirectCommandsLayoutNVXFunc) (VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateObjectTableNVXFunc) (VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
- typedef VKAPI_ATTR void (VKAPI_CALL* DestroyObjectTableNVXFunc) (VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* RegisterObjectsNVXFunc) (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* UnregisterObjectsNVXFunc) (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices);
- typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceGeneratedCommandsPropertiesNVXFunc) (VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdPushDescriptorSetKHRFunc) (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
- typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateDescriptorUpdateTemplateKHRFunc) (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
- typedef VKAPI_ATTR void (VKAPI_CALL* DestroyDescriptorUpdateTemplateKHRFunc) (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
- typedef VKAPI_ATTR void (VKAPI_CALL* UpdateDescriptorSetWithTemplateKHRFunc) (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
- typedef VKAPI_ATTR void (VKAPI_CALL* CmdPushDescriptorSetWithTemplateKHRFunc) (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetRefreshCycleDurationGOOGLEFunc) (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPastPresentationTimingGOOGLEFunc) (VkDevice device, VkSwapchainKHR swapchain, deUint32* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
m_vk.queuePresentKHR = (QueuePresentKHRFunc) GET_PROC_ADDR("vkQueuePresentKHR");
m_vk.createSharedSwapchainsKHR = (CreateSharedSwapchainsKHRFunc) GET_PROC_ADDR("vkCreateSharedSwapchainsKHR");
m_vk.trimCommandPoolKHR = (TrimCommandPoolKHRFunc) GET_PROC_ADDR("vkTrimCommandPoolKHR");
+ m_vk.cmdPushDescriptorSetKHR = (CmdPushDescriptorSetKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetKHR");
+ m_vk.createDescriptorUpdateTemplateKHR = (CreateDescriptorUpdateTemplateKHRFunc) GET_PROC_ADDR("vkCreateDescriptorUpdateTemplateKHR");
+ m_vk.destroyDescriptorUpdateTemplateKHR = (DestroyDescriptorUpdateTemplateKHRFunc) GET_PROC_ADDR("vkDestroyDescriptorUpdateTemplateKHR");
+ m_vk.updateDescriptorSetWithTemplateKHR = (UpdateDescriptorSetWithTemplateKHRFunc) GET_PROC_ADDR("vkUpdateDescriptorSetWithTemplateKHR");
+ m_vk.cmdPushDescriptorSetWithTemplateKHR = (CmdPushDescriptorSetWithTemplateKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetWithTemplateKHR");
m_vk.getSwapchainStatusKHR = (GetSwapchainStatusKHRFunc) GET_PROC_ADDR("vkGetSwapchainStatusKHR");
- m_vk.debugMarkerSetObjectTagEXT = (DebugMarkerSetObjectTagEXTFunc) GET_PROC_ADDR("vkDebugMarkerSetObjectTagEXT");
- m_vk.debugMarkerSetObjectNameEXT = (DebugMarkerSetObjectNameEXTFunc) GET_PROC_ADDR("vkDebugMarkerSetObjectNameEXT");
- m_vk.cmdDebugMarkerBeginEXT = (CmdDebugMarkerBeginEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerBeginEXT");
- m_vk.cmdDebugMarkerEndEXT = (CmdDebugMarkerEndEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerEndEXT");
- m_vk.cmdDebugMarkerInsertEXT = (CmdDebugMarkerInsertEXTFunc) GET_PROC_ADDR("vkCmdDebugMarkerInsertEXT");
- m_vk.cmdDrawIndirectCountAMD = (CmdDrawIndirectCountAMDFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountAMD");
- m_vk.cmdDrawIndexedIndirectCountAMD = (CmdDrawIndexedIndirectCountAMDFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountAMD");
- m_vk.getMemoryWin32HandleNV = (GetMemoryWin32HandleNVFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleNV");
+m_vk.getMemoryWin32HandleKHX = (GetMemoryWin32HandleKHXFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleKHX");
++m_vk.getMemoryWin32HandlePropertiesKHX = (GetMemoryWin32HandlePropertiesKHXFunc) GET_PROC_ADDR("vkGetMemoryWin32HandlePropertiesKHX");
+m_vk.getMemoryFdKHX = (GetMemoryFdKHXFunc) GET_PROC_ADDR("vkGetMemoryFdKHX");
++m_vk.getMemoryFdPropertiesKHX = (GetMemoryFdPropertiesKHXFunc) GET_PROC_ADDR("vkGetMemoryFdPropertiesKHX");
+m_vk.importSemaphoreWin32HandleKHX = (ImportSemaphoreWin32HandleKHXFunc) GET_PROC_ADDR("vkImportSemaphoreWin32HandleKHX");
+m_vk.getSemaphoreWin32HandleKHX = (GetSemaphoreWin32HandleKHXFunc) GET_PROC_ADDR("vkGetSemaphoreWin32HandleKHX");
+m_vk.importSemaphoreFdKHX = (ImportSemaphoreFdKHXFunc) GET_PROC_ADDR("vkImportSemaphoreFdKHX");
+m_vk.getSemaphoreFdKHX = (GetSemaphoreFdKHXFunc) GET_PROC_ADDR("vkGetSemaphoreFdKHX");
- m_vk.cmdProcessCommandsNVX = (CmdProcessCommandsNVXFunc) GET_PROC_ADDR("vkCmdProcessCommandsNVX");
- m_vk.cmdReserveSpaceForCommandsNVX = (CmdReserveSpaceForCommandsNVXFunc) GET_PROC_ADDR("vkCmdReserveSpaceForCommandsNVX");
- m_vk.createIndirectCommandsLayoutNVX = (CreateIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkCreateIndirectCommandsLayoutNVX");
- m_vk.destroyIndirectCommandsLayoutNVX = (DestroyIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkDestroyIndirectCommandsLayoutNVX");
- m_vk.createObjectTableNVX = (CreateObjectTableNVXFunc) GET_PROC_ADDR("vkCreateObjectTableNVX");
- m_vk.destroyObjectTableNVX = (DestroyObjectTableNVXFunc) GET_PROC_ADDR("vkDestroyObjectTableNVX");
- m_vk.registerObjectsNVX = (RegisterObjectsNVXFunc) GET_PROC_ADDR("vkRegisterObjectsNVX");
- m_vk.unregisterObjectsNVX = (UnregisterObjectsNVXFunc) GET_PROC_ADDR("vkUnregisterObjectsNVX");
- m_vk.cmdPushDescriptorSetKHR = (CmdPushDescriptorSetKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetKHR");
- m_vk.createDescriptorUpdateTemplateKHR = (CreateDescriptorUpdateTemplateKHRFunc) GET_PROC_ADDR("vkCreateDescriptorUpdateTemplateKHR");
- m_vk.destroyDescriptorUpdateTemplateKHR = (DestroyDescriptorUpdateTemplateKHRFunc) GET_PROC_ADDR("vkDestroyDescriptorUpdateTemplateKHR");
- m_vk.updateDescriptorSetWithTemplateKHR = (UpdateDescriptorSetWithTemplateKHRFunc) GET_PROC_ADDR("vkUpdateDescriptorSetWithTemplateKHR");
- m_vk.cmdPushDescriptorSetWithTemplateKHR = (CmdPushDescriptorSetWithTemplateKHRFunc) GET_PROC_ADDR("vkCmdPushDescriptorSetWithTemplateKHR");
m_vk.getRefreshCycleDurationGOOGLE = (GetRefreshCycleDurationGOOGLEFunc) GET_PROC_ADDR("vkGetRefreshCycleDurationGOOGLE");
m_vk.getPastPresentationTimingGOOGLE = (GetPastPresentationTimingGOOGLEFunc) GET_PROC_ADDR("vkGetPastPresentationTimingGOOGLE");
m_vk.createDebugReportCallbackEXT = (CreateDebugReportCallbackEXTFunc) GET_PROC_ADDR("vkCreateDebugReportCallbackEXT");
m_vk.destroyDebugReportCallbackEXT = (DestroyDebugReportCallbackEXTFunc) GET_PROC_ADDR("vkDestroyDebugReportCallbackEXT");
m_vk.debugReportMessageEXT = (DebugReportMessageEXTFunc) GET_PROC_ADDR("vkDebugReportMessageEXT");
- m_vk.getPhysicalDeviceExternalImageFormatPropertiesNV = (GetPhysicalDeviceExternalImageFormatPropertiesNVFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
+m_vk.getPhysicalDeviceExternalBufferPropertiesKHX = (GetPhysicalDeviceExternalBufferPropertiesKHXFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExternalBufferPropertiesKHX");
+m_vk.getPhysicalDeviceExternalSemaphorePropertiesKHX = (GetPhysicalDeviceExternalSemaphorePropertiesKHXFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExternalSemaphorePropertiesKHX");
- m_vk.getPhysicalDeviceGeneratedCommandsPropertiesNVX = (GetPhysicalDeviceGeneratedCommandsPropertiesNVXFunc) GET_PROC_ADDR("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
{
m_vk.debugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
}
- VkResult InstanceDriver::getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const
- {
- return m_vk.getPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
- }
-
+
-
- void InstanceDriver::getPhysicalDeviceGeneratedCommandsPropertiesNVX (VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) const
- {
- m_vk.getPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits);
- }
+void InstanceDriver::getPhysicalDeviceExternalBufferPropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties) const
+{
+ m_vk.getPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+
+void InstanceDriver::getPhysicalDeviceExternalSemaphorePropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties) const
+{
+ m_vk.getPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
CreateDebugReportCallbackEXTFunc createDebugReportCallbackEXT;
DestroyDebugReportCallbackEXTFunc destroyDebugReportCallbackEXT;
DebugReportMessageEXTFunc debugReportMessageEXT;
- GetPhysicalDeviceExternalImageFormatPropertiesNVFunc getPhysicalDeviceExternalImageFormatPropertiesNV;
+GetPhysicalDeviceExternalBufferPropertiesKHXFunc getPhysicalDeviceExternalBufferPropertiesKHX;
+GetPhysicalDeviceExternalSemaphorePropertiesKHXFunc getPhysicalDeviceExternalSemaphorePropertiesKHX;
- GetPhysicalDeviceGeneratedCommandsPropertiesNVXFunc getPhysicalDeviceGeneratedCommandsPropertiesNVX;
DE_UNREF(pMessage);
}
- VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo)
- {
- DE_UNREF(device);
- DE_UNREF(pTagInfo);
- return VK_SUCCESS;
- }
-
- VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo)
- {
- DE_UNREF(device);
- DE_UNREF(pNameInfo);
- return VK_SUCCESS;
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(pMarkerInfo);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
- {
- DE_UNREF(commandBuffer);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(pMarkerInfo);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(buffer);
- DE_UNREF(offset);
- DE_UNREF(countBuffer);
- DE_UNREF(countBufferOffset);
- DE_UNREF(maxDrawCount);
- DE_UNREF(stride);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(buffer);
- DE_UNREF(offset);
- DE_UNREF(countBuffer);
- DE_UNREF(countBufferOffset);
- DE_UNREF(maxDrawCount);
- DE_UNREF(stride);
- }
-
- VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
++VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferPropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties)
+{
+ DE_UNREF(physicalDevice);
- DE_UNREF(format);
- DE_UNREF(type);
- DE_UNREF(tiling);
- DE_UNREF(usage);
- DE_UNREF(flags);
- DE_UNREF(externalHandleType);
- DE_UNREF(pExternalImageFormatProperties);
- return VK_SUCCESS;
++ DE_UNREF(pExternalBufferInfo);
++ DE_UNREF(pExternalBufferProperties);
+}
+
- VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle)
++VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle)
+{
+ DE_UNREF(device);
+ DE_UNREF(memory);
+ DE_UNREF(handleType);
+ DE_UNREF(pHandle);
+ return VK_SUCCESS;
+}
+
- VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferPropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties)
++VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties)
+{
- DE_UNREF(physicalDevice);
- DE_UNREF(pExternalBufferInfo);
- DE_UNREF(pExternalBufferProperties);
++ DE_UNREF(device);
++ DE_UNREF(handleType);
++ DE_UNREF(handle);
++ DE_UNREF(pMemoryWin32HandleProperties);
++ return VK_SUCCESS;
+}
+
- VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle)
++VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd)
+{
+ DE_UNREF(device);
+ DE_UNREF(memory);
+ DE_UNREF(handleType);
- DE_UNREF(pHandle);
++ DE_UNREF(pFd);
+ return VK_SUCCESS;
+}
+
- VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd)
++VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdPropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties)
+{
+ DE_UNREF(device);
- DE_UNREF(memory);
+ DE_UNREF(handleType);
- DE_UNREF(pFd);
++ DE_UNREF(fd);
++ DE_UNREF(pMemoryFdProperties);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalSemaphorePropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties)
+{
+ DE_UNREF(physicalDevice);
+ DE_UNREF(pExternalSemaphoreInfo);
+ DE_UNREF(pExternalSemaphoreProperties);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHX (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo)
+{
+ DE_UNREF(device);
+ DE_UNREF(pImportSemaphoreWin32HandleInfo);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle)
+{
+ DE_UNREF(device);
+ DE_UNREF(semaphore);
+ DE_UNREF(handleType);
+ DE_UNREF(pHandle);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreFdKHX (VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo)
+{
+ DE_UNREF(device);
+ DE_UNREF(pImportSemaphoreFdInfo);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreFdKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd)
+{
+ DE_UNREF(device);
+ DE_UNREF(semaphore);
+ DE_UNREF(handleType);
+ DE_UNREF(pFd);
+ return VK_SUCCESS;
+}
+
- VKAPI_ATTR void VKAPI_CALL cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(pProcessCommandsInfo);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(pReserveSpaceInfo);
- }
-
- VKAPI_ATTR VkResult VKAPI_CALL registerObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices)
- {
- DE_UNREF(device);
- DE_UNREF(objectTable);
- DE_UNREF(objectCount);
- DE_UNREF(ppObjectTableEntries);
- DE_UNREF(pObjectIndices);
- return VK_SUCCESS;
- }
-
- VKAPI_ATTR VkResult VKAPI_CALL unregisterObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices)
- {
- DE_UNREF(device);
- DE_UNREF(objectTable);
- DE_UNREF(objectCount);
- DE_UNREF(pObjectEntryTypes);
- DE_UNREF(pObjectIndices);
- return VK_SUCCESS;
- }
-
- VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceGeneratedCommandsPropertiesNVX (VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits)
- {
- DE_UNREF(physicalDevice);
- DE_UNREF(pFeatures);
- DE_UNREF(pLimits);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(pipelineBindPoint);
- DE_UNREF(layout);
- DE_UNREF(set);
- DE_UNREF(descriptorWriteCount);
- DE_UNREF(pDescriptorWrites);
- }
-
- VKAPI_ATTR void VKAPI_CALL updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData)
- {
- DE_UNREF(device);
- DE_UNREF(descriptorSet);
- DE_UNREF(descriptorUpdateTemplate);
- DE_UNREF(pData);
- }
-
- VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData)
- {
- DE_UNREF(commandBuffer);
- DE_UNREF(descriptorUpdateTemplate);
- DE_UNREF(layout);
- DE_UNREF(set);
- DE_UNREF(pData);
- }
-
VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
DE_UNREF(device);
VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT, createDebugReportCallbackEXT),
VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT, destroyDebugReportCallbackEXT),
VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT, debugReportMessageEXT),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalImageFormatPropertiesNV, getPhysicalDeviceExternalImageFormatPropertiesNV),
+ VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHX, getPhysicalDeviceExternalBufferPropertiesKHX),
+ VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHX, getPhysicalDeviceExternalSemaphorePropertiesKHX),
- VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, getPhysicalDeviceGeneratedCommandsPropertiesNVX),
};
static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
VK_NULL_FUNC_ENTRY(vkQueuePresentKHR, queuePresentKHR),
VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR, createSharedSwapchainsKHR),
VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR, trimCommandPoolKHR),
+ VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR, cmdPushDescriptorSetKHR),
+ VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR, createDescriptorUpdateTemplateKHR),
+ VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR, destroyDescriptorUpdateTemplateKHR),
+ VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR, updateDescriptorSetWithTemplateKHR),
+ VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR, cmdPushDescriptorSetWithTemplateKHR),
VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR, getSwapchainStatusKHR),
- VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT, debugMarkerSetObjectTagEXT),
- VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT, debugMarkerSetObjectNameEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT, cmdDebugMarkerBeginEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT, cmdDebugMarkerEndEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT, cmdDebugMarkerInsertEXT),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountAMD, cmdDrawIndirectCountAMD),
- VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountAMD, cmdDrawIndexedIndirectCountAMD),
- VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV, getMemoryWin32HandleNV),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHX, getMemoryWin32HandleKHX),
++ VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHX, getMemoryWin32HandlePropertiesKHX),
+ VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHX, getMemoryFdKHX),
++ VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHX, getMemoryFdPropertiesKHX),
+ VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHX, importSemaphoreWin32HandleKHX),
+ VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHX, getSemaphoreWin32HandleKHX),
+ VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHX, importSemaphoreFdKHX),
+ VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHX, getSemaphoreFdKHX),
- VK_NULL_FUNC_ENTRY(vkCmdProcessCommandsNVX, cmdProcessCommandsNVX),
- VK_NULL_FUNC_ENTRY(vkCmdReserveSpaceForCommandsNVX, cmdReserveSpaceForCommandsNVX),
- VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNVX, createIndirectCommandsLayoutNVX),
- VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNVX, destroyIndirectCommandsLayoutNVX),
- VK_NULL_FUNC_ENTRY(vkCreateObjectTableNVX, createObjectTableNVX),
- VK_NULL_FUNC_ENTRY(vkDestroyObjectTableNVX, destroyObjectTableNVX),
- VK_NULL_FUNC_ENTRY(vkRegisterObjectsNVX, registerObjectsNVX),
- VK_NULL_FUNC_ENTRY(vkUnregisterObjectsNVX, unregisterObjectsNVX),
- VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR, cmdPushDescriptorSetKHR),
- VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR, createDescriptorUpdateTemplateKHR),
- VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR, destroyDescriptorUpdateTemplateKHR),
- VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR, updateDescriptorSetWithTemplateKHR),
- VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR, cmdPushDescriptorSetWithTemplateKHR),
VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE, getRefreshCycleDurationGOOGLE),
VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE, getPastPresentationTimingGOOGLE),
};
tcu::Format::Bitfield<32> getStencilFaceFlagsStr (VkStencilFaceFlags value);
tcu::Format::Bitfield<32> getSurfaceTransformFlagsKHRStr (VkSurfaceTransformFlagsKHR value);
tcu::Format::Bitfield<32> getCompositeAlphaFlagsKHRStr (VkCompositeAlphaFlagsKHR value);
+ tcu::Format::Bitfield<32> getSwapchainCreateFlagsKHRStr (VkSwapchainCreateFlagsKHR value);
tcu::Format::Bitfield<32> getDisplayPlaneAlphaFlagsKHRStr (VkDisplayPlaneAlphaFlagsKHR value);
tcu::Format::Bitfield<32> getDebugReportFlagsEXTStr (VkDebugReportFlagsEXT value);
- tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsNVStr (VkExternalMemoryHandleTypeFlagsNV value);
- tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsNVStr (VkExternalMemoryFeatureFlagsNV value);
+tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsKHXStr (VkExternalMemoryHandleTypeFlagsKHX value);
+tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsKHXStr (VkExternalMemoryFeatureFlagsKHX value);
+tcu::Format::Bitfield<32> getExternalSemaphoreHandleTypeFlagsKHXStr (VkExternalSemaphoreHandleTypeFlagsKHX value);
+tcu::Format::Bitfield<32> getExternalSemaphoreFeatureFlagsKHXStr (VkExternalSemaphoreFeatureFlagsKHX value);
- tcu::Format::Bitfield<32> getIndirectCommandsLayoutUsageFlagsNVXStr (VkIndirectCommandsLayoutUsageFlagsNVX value);
- tcu::Format::Bitfield<32> getObjectEntryUsageFlagsNVXStr (VkObjectEntryUsageFlagsNVX value);
tcu::Format::Bitfield<32> getInstanceCreateFlagsStr (VkInstanceCreateFlags value);
tcu::Format::Bitfield<32> getDeviceCreateFlagsStr (VkDeviceCreateFlags value);
tcu::Format::Bitfield<32> getDeviceQueueCreateFlagsStr (VkDeviceQueueCreateFlags value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSparseImageFormatInfo2KHR& value);
+ std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePushDescriptorPropertiesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevice16BitStorageFeaturesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkRectLayerKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPresentRegionKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPresentRegionsKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSurfaceInfo2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilities2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSurfaceFormat2KHR& value);
- std::ostream& operator<< (std::ostream& s, const VkSharedPresentSurfaceCapabilitiesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value);
- std::ostream& operator<< (std::ostream& s, const VkPipelineRasterizationStateRasterizationOrderAMD& value);
- std::ostream& operator<< (std::ostream& s, const VkDebugMarkerObjectNameInfoEXT& value);
- std::ostream& operator<< (std::ostream& s, const VkDebugMarkerObjectTagInfoEXT& value);
- std::ostream& operator<< (std::ostream& s, const VkDebugMarkerMarkerInfoEXT& value);
- std::ostream& operator<< (std::ostream& s, const VkDedicatedAllocationImageCreateInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkDedicatedAllocationBufferCreateInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkDedicatedAllocationMemoryAllocateInfoNV& value);
+std::ostream& operator<< (std::ostream& s, const VkRenderPassMultiviewCreateInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewFeaturesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewPropertiesKHX& value);
- std::ostream& operator<< (std::ostream& s, const VkExternalImageFormatPropertiesNV& value);
- std::ostream& operator<< (std::ostream& s, const VkExternalMemoryImageCreateInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkExportMemoryAllocateInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkImportMemoryWin32HandleInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkExportMemoryWin32HandleInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoNV& value);
- std::ostream& operator<< (std::ostream& s, const VkValidationFlagsEXT& value);
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryPropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalImageFormatInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExternalImageFormatPropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalBufferInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExternalBufferPropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceIDPropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryImageCreateInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryBufferCreateInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExportMemoryAllocateInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkImportMemoryWin32HandleInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExportMemoryWin32HandleInfoKHX& value);
++std::ostream& operator<< (std::ostream& s, const VkMemoryWin32HandlePropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkImportMemoryFdInfoKHX& value);
++std::ostream& operator<< (std::ostream& s, const VkMemoryFdPropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalSemaphoreInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExternalSemaphorePropertiesKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExportSemaphoreCreateInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkImportSemaphoreWin32HandleInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkExportSemaphoreWin32HandleInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkD3D12FenceSubmitInfoKHX& value);
+std::ostream& operator<< (std::ostream& s, const VkImportSemaphoreFdInfoKHX& value);
- std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsFeaturesNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsLimitsNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsTokenNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsLayoutTokenNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsLayoutCreateInfoNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkCmdProcessCommandsInfoNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkCmdReserveSpaceForCommandsInfoNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTableCreateInfoNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTableEntryNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTablePipelineEntryNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTableDescriptorSetEntryNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTableVertexBufferEntryNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTableIndexBufferEntryNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkObjectTablePushConstantEntryNVX& value);
- std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePushDescriptorPropertiesKHR& value);
- std::ostream& operator<< (std::ostream& s, const VkDescriptorUpdateTemplateEntryKHR& value);
- std::ostream& operator<< (std::ostream& s, const VkDescriptorUpdateTemplateCreateInfoKHR& value);
std::ostream& operator<< (std::ostream& s, const VkRefreshCycleDurationGOOGLE& value);
std::ostream& operator<< (std::ostream& s, const VkPastPresentationTimingGOOGLE& value);
std::ostream& operator<< (std::ostream& s, const VkPresentTimeGOOGLE& value);
{
switch (value)
{
-- case VK_SUCCESS: return "VK_SUCCESS";
-- 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_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_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
-- case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
-- case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
-- case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT";
-- case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT";
-- case VK_ERROR_FEATURE_NOT_PRESENT: return "VK_ERROR_FEATURE_NOT_PRESENT";
-- case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
-- case VK_ERROR_TOO_MANY_OBJECTS: return "VK_ERROR_TOO_MANY_OBJECTS";
-- case VK_ERROR_FORMAT_NOT_SUPPORTED: return "VK_ERROR_FORMAT_NOT_SUPPORTED";
-- case VK_ERROR_FRAGMENTED_POOL: return "VK_ERROR_FRAGMENTED_POOL";
-- case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR";
-- case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
-- case VK_SUBOPTIMAL_KHR: return "VK_SUBOPTIMAL_KHR";
-- case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR";
-- case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
-- case VK_ERROR_VALIDATION_FAILED_EXT: return "VK_ERROR_VALIDATION_FAILED_EXT";
-- case VK_ERROR_INVALID_SHADER_NV: return "VK_ERROR_INVALID_SHADER_NV";
-- case VK_ERROR_OUT_OF_POOL_MEMORY_KHR: return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
-- default: return DE_NULL;
++ case VK_SUCCESS: return "VK_SUCCESS";
++ 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_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_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
++ case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
++ case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
++ case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT";
++ case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT";
++ case VK_ERROR_FEATURE_NOT_PRESENT: return "VK_ERROR_FEATURE_NOT_PRESENT";
++ case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
++ case VK_ERROR_TOO_MANY_OBJECTS: return "VK_ERROR_TOO_MANY_OBJECTS";
++ case VK_ERROR_FORMAT_NOT_SUPPORTED: return "VK_ERROR_FORMAT_NOT_SUPPORTED";
++ case VK_ERROR_FRAGMENTED_POOL: return "VK_ERROR_FRAGMENTED_POOL";
++ case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR";
++ case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
++ case VK_SUBOPTIMAL_KHR: return "VK_SUBOPTIMAL_KHR";
++ case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR";
++ case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
++ case VK_ERROR_VALIDATION_FAILED_EXT: return "VK_ERROR_VALIDATION_FAILED_EXT";
++ case VK_ERROR_INVALID_SHADER_NV: return "VK_ERROR_INVALID_SHADER_NV";
++ case VK_ERROR_OUT_OF_POOL_MEMORY_KHR: return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
++ case VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX: return "VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX";
++ default: return DE_NULL;
}
}
{
switch (value)
{
- case VK_STRUCTURE_TYPE_APPLICATION_INFO: return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
- case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SUBMIT_INFO: return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
- case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
- case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: return "VK_STRUCTURE_TYPE_BIND_SPARSE_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_EVENT_CREATE_INFO: return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
- case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_QUERY_POOL_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_IMAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_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_RASTERIZATION_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_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_DEPTH_STENCIL_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_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_DYNAMIC_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_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_DESCRIPTOR_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_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_FRAMEBUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
- case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
- case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
- 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_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
- case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
- case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
- case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
- case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD";
- case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT";
- case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT";
- case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT";
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV";
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV";
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV";
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX";
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV";
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV";
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV";
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV";
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR";
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR";
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR";
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR";
- case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR";
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
- case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX";
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX";
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX";
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX";
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX: return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX";
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX";
- case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX";
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX";
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX: return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX";
- case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR";
- case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX: return "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX";
- case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX";
- case VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX: return "VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX";
- case VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX: return "VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX";
- case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX: return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX";
- case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX: return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX";
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
- case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
- default: return DE_NULL;
+ case VK_STRUCTURE_TYPE_APPLICATION_INFO: return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
+ case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SUBMIT_INFO: return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
+ case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
+ case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: return "VK_STRUCTURE_TYPE_BIND_SPARSE_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_EVENT_CREATE_INFO: return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_QUERY_POOL_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_IMAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_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_RASTERIZATION_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_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_DEPTH_STENCIL_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_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_DYNAMIC_STATE_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_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_DESCRIPTOR_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_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_FRAMEBUFFER_CREATE_INFO: return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
+ case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
+ 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_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
++ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX";
++ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX";
++ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX";
++ case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX: return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX";
++ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX";
++ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX: return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX";
++ case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
++ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
+ default: return DE_NULL;
}
}
tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, "VK_IMAGE_CREATE_SPARSE_ALIASED_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_IMAGE_CREATE_BIND_SFR_BIT_KHX, "VK_IMAGE_CREATE_BIND_SFR_BIT_KHX"),
tcu::Format::BitDesc(VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR"),
};
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_HEAP_DEVICE_LOCAL_BIT, "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"),
++ tcu::Format::BitDesc(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"),
++ tcu::Format::BitDesc(VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX, "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX"),
};
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_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"),
+ 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"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX"),
++ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE_KHX, "VK_PIPELINE_CREATE_DISPATCH_BASE_KHX"),
};
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_DEPENDENCY_BY_REGION_BIT, "VK_DEPENDENCY_BY_REGION_BIT"),
- tcu::Format::BitDesc(VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX, "VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX"),
- tcu::Format::BitDesc(VK_DEPENDENCY_BY_REGION_BIT, "VK_DEPENDENCY_BY_REGION_BIT"),
++ tcu::Format::BitDesc(VK_DEPENDENCY_BY_REGION_BIT, "VK_DEPENDENCY_BY_REGION_BIT"),
++ tcu::Format::BitDesc(VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX, "VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX"),
++ tcu::Format::BitDesc(VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX, "VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
- return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+ tcu::Format::Bitfield<32> getSwapchainCreateFlagsKHRStr (VkSwapchainCreateFlagsKHR value)
+ {
++ static const tcu::Format::BitDesc s_desc[] =
++ {
++ tcu::Format::BitDesc(VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX, "VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX"),
++ };
++ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+ }
+
tcu::Format::Bitfield<32> getDisplayPlaneAlphaFlagsKHRStr (VkDisplayPlaneAlphaFlagsKHR value)
{
static const tcu::Format::BitDesc s_desc[] =
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
- tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsNVStr (VkExternalMemoryHandleTypeFlagsNV value)
- {
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
- }
-
- tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsNVStr (VkExternalMemoryFeatureFlagsNV value)
- {
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV, "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
- }
-
+tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsKHXStr (VkExternalMemoryHandleTypeFlagsKHX value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsKHXStr (VkExternalMemoryFeatureFlagsKHX value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX, "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX, "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getExternalSemaphoreHandleTypeFlagsKHXStr (VkExternalSemaphoreHandleTypeFlagsKHX value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getExternalSemaphoreFeatureFlagsKHXStr (VkExternalSemaphoreFeatureFlagsKHX value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX"),
+ tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX, "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
- tcu::Format::Bitfield<32> getIndirectCommandsLayoutUsageFlagsNVXStr (VkIndirectCommandsLayoutUsageFlagsNVX value)
- {
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX"),
- tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX"),
- tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX"),
- tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX, "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
- }
-
- tcu::Format::Bitfield<32> getObjectEntryUsageFlagsNVXStr (VkObjectEntryUsageFlagsNVX value)
- {
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, "VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX"),
- tcu::Format::BitDesc(VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX, "VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
- }
-
tcu::Format::Bitfield<32> getInstanceCreateFlagsStr (VkInstanceCreateFlags value)
{
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
return s;
}
- s << "\tstorageUniformBufferBlock16 = " << value.storageUniformBufferBlock16 << '\n';
- s << "\tstorageUniform16 = " << value.storageUniform16 << '\n';
+ std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePushDescriptorPropertiesKHR& value)
+ {
+ s << "VkPhysicalDevicePushDescriptorPropertiesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tmaxPushDescriptors = " << value.maxPushDescriptors << '\n';
+ s << '}';
+ return s;
+ }
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevice16BitStorageFeaturesKHR& value)
+{
+ s << "VkPhysicalDevice16BitStorageFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
++ s << "\tstorageBuffer16BitAccess = " << value.storageBuffer16BitAccess << '\n';
++ s << "\tuniformAndStorageBuffer16BitAccess = " << value.uniformAndStorageBuffer16BitAccess << '\n';
+ s << "\tstoragePushConstant16 = " << value.storagePushConstant16 << '\n';
+ s << "\tstorageInputOutput16 = " << value.storageInputOutput16 << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkRectLayerKHR& value)
{
s << "VkRectLayerKHR = {\n";
return s;
}
- std::ostream& operator<< (std::ostream& s, const VkExternalImageFormatPropertiesNV& value)
- {
- s << "VkExternalImageFormatPropertiesNV = {\n";
- s << "\timageFormatProperties = " << value.imageFormatProperties << '\n';
- s << "\texternalMemoryFeatures = " << getExternalMemoryFeatureFlagsNVStr(value.externalMemoryFeatures) << '\n';
- s << "\texportFromImportedHandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.exportFromImportedHandleTypes) << '\n';
- s << "\tcompatibleHandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.compatibleHandleTypes) << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkExternalMemoryImageCreateInfoNV& value)
- {
- s << "VkExternalMemoryImageCreateInfoNV = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.handleTypes) << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkExportMemoryAllocateInfoNV& value)
- {
- s << "VkExportMemoryAllocateInfoNV = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.handleTypes) << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkImportMemoryWin32HandleInfoNV& value)
- {
- s << "VkImportMemoryWin32HandleInfoNV = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\thandleType = " << getExternalMemoryHandleTypeFlagsNVStr(value.handleType) << '\n';
- s << "\thandle = " << value.handle << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkExportMemoryWin32HandleInfoNV& value)
- {
- s << "VkExportMemoryWin32HandleInfoNV = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tpAttributes = " << value.pAttributes << '\n';
- s << "\tdwAccess = " << value.dwAccess << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoNV& value)
- {
- s << "VkWin32KeyedMutexAcquireReleaseInfoNV = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tacquireCount = " << value.acquireCount << '\n';
- s << "\tpAcquireSyncs = " << value.pAcquireSyncs << '\n';
- s << "\tpAcquireKeys = " << value.pAcquireKeys << '\n';
- s << "\tpAcquireTimeoutMilliseconds = " << value.pAcquireTimeoutMilliseconds << '\n';
- s << "\treleaseCount = " << value.releaseCount << '\n';
- s << "\tpReleaseSyncs = " << value.pReleaseSyncs << '\n';
- s << "\tpReleaseKeys = " << value.pReleaseKeys << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkValidationFlagsEXT& value)
- {
- s << "VkValidationFlagsEXT = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tdisabledValidationCheckCount = " << value.disabledValidationCheckCount << '\n';
- s << "\tpDisabledValidationChecks = " << value.pDisabledValidationChecks << '\n';
- s << '}';
- return s;
- }
-
+std::ostream& operator<< (std::ostream& s, const VkRenderPassMultiviewCreateInfoKHX& value)
+{
+ s << "VkRenderPassMultiviewCreateInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsubpassCount = " << value.subpassCount << '\n';
+ s << "\tpViewMasks = " << value.pViewMasks << '\n';
+ s << "\tdependencyCount = " << value.dependencyCount << '\n';
+ s << "\tpViewOffsets = " << value.pViewOffsets << '\n';
+ s << "\tcorrelationMaskCount = " << value.correlationMaskCount << '\n';
+ s << "\tpCorrelationMasks = " << value.pCorrelationMasks << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewFeaturesKHX& value)
+{
+ s << "VkPhysicalDeviceMultiviewFeaturesKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tmultiview = " << value.multiview << '\n';
+ s << "\tmultiviewGeometryShader = " << value.multiviewGeometryShader << '\n';
+ s << "\tmultiviewTessellationShader = " << value.multiviewTessellationShader << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewPropertiesKHX& value)
+{
+ s << "VkPhysicalDeviceMultiviewPropertiesKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tmaxMultiviewViewCount = " << value.maxMultiviewViewCount << '\n';
+ s << "\tmaxMultiviewInstanceIndex = " << value.maxMultiviewInstanceIndex << '\n';
+ s << '}';
+ return s;
+}
+
- std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsFeaturesNVX& value)
- {
- s << "VkDeviceGeneratedCommandsFeaturesNVX = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tcomputeBindingPointSupport = " << value.computeBindingPointSupport << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsLimitsNVX& value)
- {
- s << "VkDeviceGeneratedCommandsLimitsNVX = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tmaxIndirectCommandsLayoutTokenCount = " << value.maxIndirectCommandsLayoutTokenCount << '\n';
- s << "\tmaxObjectEntryCounts = " << value.maxObjectEntryCounts << '\n';
- s << "\tminSequenceCountBufferOffsetAlignment = " << value.minSequenceCountBufferOffsetAlignment << '\n';
- s << "\tminSequenceIndexBufferOffsetAlignment = " << value.minSequenceIndexBufferOffsetAlignment << '\n';
- s << "\tminCommandsTokenBufferOffsetAlignment = " << value.minCommandsTokenBufferOffsetAlignment << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsTokenNVX& value)
- {
- s << "VkIndirectCommandsTokenNVX = {\n";
- s << "\ttokenType = " << value.tokenType << '\n';
- s << "\tbuffer = " << value.buffer << '\n';
- s << "\toffset = " << value.offset << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsLayoutTokenNVX& value)
- {
- s << "VkIndirectCommandsLayoutTokenNVX = {\n";
- s << "\ttokenType = " << value.tokenType << '\n';
- s << "\tbindingUnit = " << value.bindingUnit << '\n';
- s << "\tdynamicCount = " << value.dynamicCount << '\n';
- s << "\tdivisor = " << value.divisor << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsLayoutCreateInfoNVX& value)
- {
- s << "VkIndirectCommandsLayoutCreateInfoNVX = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tpipelineBindPoint = " << value.pipelineBindPoint << '\n';
- s << "\tflags = " << getIndirectCommandsLayoutUsageFlagsNVXStr(value.flags) << '\n';
- s << "\ttokenCount = " << value.tokenCount << '\n';
- s << "\tpTokens = " << value.pTokens << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkCmdProcessCommandsInfoNVX& value)
- {
- s << "VkCmdProcessCommandsInfoNVX = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tobjectTable = " << value.objectTable << '\n';
- s << "\tindirectCommandsLayout = " << value.indirectCommandsLayout << '\n';
- s << "\tindirectCommandsTokenCount = " << value.indirectCommandsTokenCount << '\n';
- s << "\tpIndirectCommandsTokens = " << value.pIndirectCommandsTokens << '\n';
- s << "\tmaxSequencesCount = " << value.maxSequencesCount << '\n';
- s << "\ttargetCommandBuffer = " << value.targetCommandBuffer << '\n';
- s << "\tsequencesCountBuffer = " << value.sequencesCountBuffer << '\n';
- s << "\tsequencesCountOffset = " << value.sequencesCountOffset << '\n';
- s << "\tsequencesIndexBuffer = " << value.sequencesIndexBuffer << '\n';
- s << "\tsequencesIndexOffset = " << value.sequencesIndexOffset << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkCmdReserveSpaceForCommandsInfoNVX& value)
- {
- s << "VkCmdReserveSpaceForCommandsInfoNVX = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tobjectTable = " << value.objectTable << '\n';
- s << "\tindirectCommandsLayout = " << value.indirectCommandsLayout << '\n';
- s << "\tmaxSequencesCount = " << value.maxSequencesCount << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTableCreateInfoNVX& value)
- {
- s << "VkObjectTableCreateInfoNVX = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tobjectCount = " << value.objectCount << '\n';
- s << "\tpObjectEntryTypes = " << value.pObjectEntryTypes << '\n';
- s << "\tpObjectEntryCounts = " << value.pObjectEntryCounts << '\n';
- s << "\tpObjectEntryUsageFlags = " << value.pObjectEntryUsageFlags << '\n';
- s << "\tmaxUniformBuffersPerDescriptor = " << value.maxUniformBuffersPerDescriptor << '\n';
- s << "\tmaxStorageBuffersPerDescriptor = " << value.maxStorageBuffersPerDescriptor << '\n';
- s << "\tmaxStorageImagesPerDescriptor = " << value.maxStorageImagesPerDescriptor << '\n';
- s << "\tmaxSampledImagesPerDescriptor = " << value.maxSampledImagesPerDescriptor << '\n';
- s << "\tmaxPipelineLayouts = " << value.maxPipelineLayouts << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTableEntryNVX& value)
- {
- s << "VkObjectTableEntryNVX = {\n";
- s << "\ttype = " << value.type << '\n';
- s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTablePipelineEntryNVX& value)
- {
- s << "VkObjectTablePipelineEntryNVX = {\n";
- s << "\ttype = " << value.type << '\n';
- s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
- s << "\tpipeline = " << value.pipeline << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTableDescriptorSetEntryNVX& value)
- {
- s << "VkObjectTableDescriptorSetEntryNVX = {\n";
- s << "\ttype = " << value.type << '\n';
- s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
- s << "\tpipelineLayout = " << value.pipelineLayout << '\n';
- s << "\tdescriptorSet = " << value.descriptorSet << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTableVertexBufferEntryNVX& value)
- {
- s << "VkObjectTableVertexBufferEntryNVX = {\n";
- s << "\ttype = " << value.type << '\n';
- s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
- s << "\tbuffer = " << value.buffer << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTableIndexBufferEntryNVX& value)
- {
- s << "VkObjectTableIndexBufferEntryNVX = {\n";
- s << "\ttype = " << value.type << '\n';
- s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
- s << "\tbuffer = " << value.buffer << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkObjectTablePushConstantEntryNVX& value)
- {
- s << "VkObjectTablePushConstantEntryNVX = {\n";
- s << "\ttype = " << value.type << '\n';
- s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
- s << "\tpipelineLayout = " << value.pipelineLayout << '\n';
- s << "\tstageFlags = " << getShaderStageFlagsStr(value.stageFlags) << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePushDescriptorPropertiesKHR& value)
- {
- s << "VkPhysicalDevicePushDescriptorPropertiesKHR = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tmaxPushDescriptors = " << value.maxPushDescriptors << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkDescriptorUpdateTemplateEntryKHR& value)
- {
- s << "VkDescriptorUpdateTemplateEntryKHR = {\n";
- s << "\tdstBinding = " << value.dstBinding << '\n';
- s << "\tdstArrayElement = " << value.dstArrayElement << '\n';
- s << "\tdescriptorCount = " << value.descriptorCount << '\n';
- s << "\tdescriptorType = " << value.descriptorType << '\n';
- s << "\toffset = " << value.offset << '\n';
- s << "\tstride = " << value.stride << '\n';
- s << '}';
- return s;
- }
-
- std::ostream& operator<< (std::ostream& s, const VkDescriptorUpdateTemplateCreateInfoKHR& value)
- {
- s << "VkDescriptorUpdateTemplateCreateInfoKHR = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tflags = " << getDescriptorUpdateTemplateCreateFlagsKHRStr(value.flags) << '\n';
- s << "\tdescriptorUpdateEntryCount = " << value.descriptorUpdateEntryCount << '\n';
- s << "\tpDescriptorUpdateEntries = " << value.pDescriptorUpdateEntries << '\n';
- s << "\ttemplateType = " << value.templateType << '\n';
- s << "\tdescriptorSetLayout = " << value.descriptorSetLayout << '\n';
- s << "\tpipelineBindPoint = " << value.pipelineBindPoint << '\n';
- s << "\tpipelineLayout = " << value.pipelineLayout << '\n';
- s << "\tset = " << value.set << '\n';
- s << '}';
- return s;
- }
-
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryPropertiesKHX& value)
+{
+ s << "VkExternalMemoryPropertiesKHX = {\n";
+ s << "\texternalMemoryFeatures = " << getExternalMemoryFeatureFlagsKHXStr(value.externalMemoryFeatures) << '\n';
+ s << "\texportFromImportedHandleTypes = " << getExternalMemoryHandleTypeFlagsKHXStr(value.exportFromImportedHandleTypes) << '\n';
+ s << "\tcompatibleHandleTypes = " << getExternalMemoryHandleTypeFlagsKHXStr(value.compatibleHandleTypes) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalImageFormatInfoKHX& value)
+{
+ s << "VkPhysicalDeviceExternalImageFormatInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleType = " << value.handleType << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalImageFormatPropertiesKHX& value)
+{
+ s << "VkExternalImageFormatPropertiesKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\texternalMemoryProperties = " << value.externalMemoryProperties << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalBufferInfoKHX& value)
+{
+ s << "VkPhysicalDeviceExternalBufferInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tflags = " << getBufferCreateFlagsStr(value.flags) << '\n';
+ s << "\tusage = " << getBufferUsageFlagsStr(value.usage) << '\n';
+ s << "\thandleType = " << value.handleType << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalBufferPropertiesKHX& value)
+{
+ s << "VkExternalBufferPropertiesKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\texternalMemoryProperties = " << value.externalMemoryProperties << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceIDPropertiesKHX& value)
+{
+ s << "VkPhysicalDeviceIDPropertiesKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tdeviceUUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.deviceUUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.deviceUUID))) << '\n';
+ s << "\tdriverUUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.driverUUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.driverUUID))) << '\n';
+ s << "\tdeviceLUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.deviceLUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.deviceLUID))) << '\n';
+ s << "\tdeviceLUIDValid = " << value.deviceLUIDValid << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryImageCreateInfoKHX& value)
+{
+ s << "VkExternalMemoryImageCreateInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsKHXStr(value.handleTypes) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryBufferCreateInfoKHX& value)
+{
+ s << "VkExternalMemoryBufferCreateInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsKHXStr(value.handleTypes) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportMemoryAllocateInfoKHX& value)
+{
+ s << "VkExportMemoryAllocateInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsKHXStr(value.handleTypes) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportMemoryWin32HandleInfoKHX& value)
+{
+ s << "VkImportMemoryWin32HandleInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleType = " << value.handleType << '\n';
+ s << "\thandle = " << value.handle << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportMemoryWin32HandleInfoKHX& value)
+{
+ s << "VkExportMemoryWin32HandleInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tpAttributes = " << value.pAttributes << '\n';
+ s << "\tdwAccess = " << value.dwAccess << '\n';
+ s << "\tname = " << getCharPtrStr(value.name) << '\n';
+ s << '}';
+ return s;
+}
+
++std::ostream& operator<< (std::ostream& s, const VkMemoryWin32HandlePropertiesKHX& value)
++{
++ s << "VkMemoryWin32HandlePropertiesKHX = {\n";
++ s << "\tsType = " << value.sType << '\n';
++ s << "\tpNext = " << value.pNext << '\n';
++ s << "\tmemoryTypeBits = " << value.memoryTypeBits << '\n';
++ s << '}';
++ return s;
++}
++
+std::ostream& operator<< (std::ostream& s, const VkImportMemoryFdInfoKHX& value)
+{
+ s << "VkImportMemoryFdInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleType = " << value.handleType << '\n';
+ s << "\tfd = " << value.fd << '\n';
+ s << '}';
+ return s;
+}
+
++std::ostream& operator<< (std::ostream& s, const VkMemoryFdPropertiesKHX& value)
++{
++ s << "VkMemoryFdPropertiesKHX = {\n";
++ s << "\tsType = " << value.sType << '\n';
++ s << "\tpNext = " << value.pNext << '\n';
++ s << "\tmemoryTypeBits = " << value.memoryTypeBits << '\n';
++ s << '}';
++ return s;
++}
++
+std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoKHX& value)
+{
+ s << "VkWin32KeyedMutexAcquireReleaseInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tacquireCount = " << value.acquireCount << '\n';
+ s << "\tpAcquireSyncs = " << value.pAcquireSyncs << '\n';
+ s << "\tpAcquireKeys = " << value.pAcquireKeys << '\n';
+ s << "\tpAcquireTimeouts = " << value.pAcquireTimeouts << '\n';
+ s << "\treleaseCount = " << value.releaseCount << '\n';
+ s << "\tpReleaseSyncs = " << value.pReleaseSyncs << '\n';
+ s << "\tpReleaseKeys = " << value.pReleaseKeys << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalSemaphoreInfoKHX& value)
+{
+ s << "VkPhysicalDeviceExternalSemaphoreInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleType = " << value.handleType << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalSemaphorePropertiesKHX& value)
+{
+ s << "VkExternalSemaphorePropertiesKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\texportFromImportedHandleTypes = " << getExternalSemaphoreHandleTypeFlagsKHXStr(value.exportFromImportedHandleTypes) << '\n';
+ s << "\tcompatibleHandleTypes = " << getExternalSemaphoreHandleTypeFlagsKHXStr(value.compatibleHandleTypes) << '\n';
+ s << "\texternalSemaphoreFeatures = " << getExternalSemaphoreFeatureFlagsKHXStr(value.externalSemaphoreFeatures) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportSemaphoreCreateInfoKHX& value)
+{
+ s << "VkExportSemaphoreCreateInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\thandleTypes = " << getExternalSemaphoreHandleTypeFlagsKHXStr(value.handleTypes) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportSemaphoreWin32HandleInfoKHX& value)
+{
+ s << "VkImportSemaphoreWin32HandleInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsemaphore = " << value.semaphore << '\n';
+ s << "\thandleType = " << getExternalSemaphoreHandleTypeFlagsKHXStr(value.handleType) << '\n';
+ s << "\thandle = " << value.handle << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportSemaphoreWin32HandleInfoKHX& value)
+{
+ s << "VkExportSemaphoreWin32HandleInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tpAttributes = " << value.pAttributes << '\n';
+ s << "\tdwAccess = " << value.dwAccess << '\n';
+ s << "\tname = " << getCharPtrStr(value.name) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkD3D12FenceSubmitInfoKHX& value)
+{
+ s << "VkD3D12FenceSubmitInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\twaitSemaphoreValuesCount = " << value.waitSemaphoreValuesCount << '\n';
+ s << "\tpWaitSemaphoreValues = " << value.pWaitSemaphoreValues << '\n';
+ s << "\tsignalSemaphoreValuesCount = " << value.signalSemaphoreValuesCount << '\n';
+ s << "\tpSignalSemaphoreValues = " << value.pSignalSemaphoreValues << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportSemaphoreFdInfoKHX& value)
+{
+ s << "VkImportSemaphoreFdInfoKHX = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsemaphore = " << value.semaphore << '\n';
+ s << "\thandleType = " << value.handleType << '\n';
+ s << "\tfd = " << value.fd << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkRefreshCycleDurationGOOGLE& value)
{
s << "VkRefreshCycleDurationGOOGLE = {\n";
VkImageTiling tiling;
};
- const void* pNext;
- VkBool32 storageUniformBufferBlock16;
- VkBool32 storageUniform16;
+ struct VkPhysicalDevicePushDescriptorPropertiesKHR
+ {
+ VkStructureType sType;
+ void* pNext;
+ deUint32 maxPushDescriptors;
+ };
+
+struct VkPhysicalDevice16BitStorageFeaturesKHR
+{
+ VkStructureType sType;
++ void* pNext;
++ VkBool32 storageBuffer16BitAccess;
++ VkBool32 uniformAndStorageBuffer16BitAccess;
+ VkBool32 storagePushConstant16;
+ VkBool32 storageInputOutput16;
+};
+
struct VkRectLayerKHR
{
VkOffset2D offset;
void* pUserData;
};
- struct VkPipelineRasterizationStateRasterizationOrderAMD
- {
- VkStructureType sType;
- const void* pNext;
- VkRasterizationOrderAMD rasterizationOrder;
- };
-
- struct VkDebugMarkerObjectNameInfoEXT
- {
- VkStructureType sType;
- const void* pNext;
- VkDebugReportObjectTypeEXT objectType;
- deUint64 object;
- const char* pObjectName;
- };
-
- struct VkDebugMarkerObjectTagInfoEXT
- {
- VkStructureType sType;
- const void* pNext;
- VkDebugReportObjectTypeEXT objectType;
- deUint64 object;
- deUint64 tagName;
- deUintptr tagSize;
- const void* pTag;
- };
-
- struct VkDebugMarkerMarkerInfoEXT
- {
- VkStructureType sType;
- const void* pNext;
- const char* pMarkerName;
- float color[4];
- };
-
- struct VkDedicatedAllocationImageCreateInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- VkBool32 dedicatedAllocation;
- };
-
- struct VkDedicatedAllocationBufferCreateInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- VkBool32 dedicatedAllocation;
- };
-
- struct VkDedicatedAllocationMemoryAllocateInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- VkImage image;
- VkBuffer buffer;
- };
-
+struct VkRenderPassMultiviewCreateInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 subpassCount;
+ const deUint32* pViewMasks;
+ deUint32 dependencyCount;
+ const deInt32* pViewOffsets;
+ deUint32 correlationMaskCount;
+ const deUint32* pCorrelationMasks;
+};
+
+struct VkPhysicalDeviceMultiviewFeaturesKHX
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 multiview;
+ VkBool32 multiviewGeometryShader;
+ VkBool32 multiviewTessellationShader;
+};
+
+struct VkPhysicalDeviceMultiviewPropertiesKHX
+{
+ VkStructureType sType;
+ void* pNext;
+ deUint32 maxMultiviewViewCount;
+ deUint32 maxMultiviewInstanceIndex;
+};
+
- struct VkExternalImageFormatPropertiesNV
- {
- VkImageFormatProperties imageFormatProperties;
- VkExternalMemoryFeatureFlagsNV externalMemoryFeatures;
- VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
- VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
- };
-
- struct VkExternalMemoryImageCreateInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- VkExternalMemoryHandleTypeFlagsNV handleTypes;
- };
-
- struct VkExportMemoryAllocateInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- VkExternalMemoryHandleTypeFlagsNV handleTypes;
- };
-
- struct VkImportMemoryWin32HandleInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- VkExternalMemoryHandleTypeFlagsNV handleType;
- pt::Win32Handle handle;
- };
-
- struct VkExportMemoryWin32HandleInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- pt::Win32SecurityAttributesPtr pAttributes;
- deUint32 dwAccess;
- };
-
- struct VkWin32KeyedMutexAcquireReleaseInfoNV
- {
- VkStructureType sType;
- const void* pNext;
- deUint32 acquireCount;
- const VkDeviceMemory* pAcquireSyncs;
- const deUint64* pAcquireKeys;
- const deUint32* pAcquireTimeoutMilliseconds;
- deUint32 releaseCount;
- const VkDeviceMemory* pReleaseSyncs;
- const deUint64* pReleaseKeys;
- };
-
- struct VkValidationFlagsEXT
- {
- VkStructureType sType;
- const void* pNext;
- deUint32 disabledValidationCheckCount;
- VkValidationCheckEXT* pDisabledValidationChecks;
- };
-
+struct VkExternalMemoryPropertiesKHX
+{
+ VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures;
+ VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes;
+ VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes;
+};
+
+struct VkPhysicalDeviceExternalImageFormatInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+};
+
+struct VkExternalImageFormatPropertiesKHX
+{
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ VkExternalMemoryPropertiesKHX externalMemoryProperties;
+};
+
+struct VkPhysicalDeviceExternalBufferInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCreateFlags flags;
+ VkBufferUsageFlags usage;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+};
+
+struct VkExternalBufferPropertiesKHX
+{
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ VkExternalMemoryPropertiesKHX externalMemoryProperties;
+};
+
+struct VkPhysicalDeviceIDPropertiesKHX
+{
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ deUint8 deviceUUID[VK_UUID_SIZE];
+ deUint8 driverUUID[VK_UUID_SIZE];
+ deUint8 deviceLUID[VK_LUID_SIZE_KHX];
+ VkBool32 deviceLUIDValid;
+};
+
+struct VkExternalMemoryImageCreateInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes;
+};
+
+struct VkExternalMemoryBufferCreateInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes;
+};
+
+struct VkExportMemoryAllocateInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes;
+};
+
+struct VkImportMemoryWin32HandleInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+ pt::Win32Handle handle;
+};
+
+struct VkExportMemoryWin32HandleInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ pt::Win32SecurityAttributesPtr pAttributes;
+ deUint32 dwAccess;
+ char* name;
+};
+
++struct VkMemoryWin32HandlePropertiesKHX
++{
++ VkStructureType sType;
++ void* pNext;
++ deUint32 memoryTypeBits;
++};
++
+struct VkImportMemoryFdInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+ int fd;
+};
+
++struct VkMemoryFdPropertiesKHX
++{
++ VkStructureType sType;
++ void* pNext;
++ deUint32 memoryTypeBits;
++};
++
+struct VkWin32KeyedMutexAcquireReleaseInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 acquireCount;
+ const VkDeviceMemory* pAcquireSyncs;
+ const deUint64* pAcquireKeys;
+ const deUint32* pAcquireTimeouts;
+ deUint32 releaseCount;
+ const VkDeviceMemory* pReleaseSyncs;
+ const deUint64* pReleaseKeys;
+};
+
+struct VkPhysicalDeviceExternalSemaphoreInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType;
+};
+
+struct VkExternalSemaphorePropertiesKHX
+{
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes;
+ VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes;
+ VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures;
+};
+
+struct VkExportSemaphoreCreateInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalSemaphoreHandleTypeFlagsKHX handleTypes;
+};
+
+struct VkImportSemaphoreWin32HandleInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagsKHX handleType;
+ pt::Win32Handle handle;
+};
+
+struct VkExportSemaphoreWin32HandleInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ pt::Win32SecurityAttributesPtr pAttributes;
+ deUint32 dwAccess;
+ char* name;
+};
+
+struct VkD3D12FenceSubmitInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 waitSemaphoreValuesCount;
+ const deUint64* pWaitSemaphoreValues;
+ deUint32 signalSemaphoreValuesCount;
+ const deUint64* pSignalSemaphoreValues;
+};
+
+struct VkImportSemaphoreFdInfoKHX
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType;
+ int fd;
+};
+
- struct VkDeviceGeneratedCommandsFeaturesNVX
- {
- VkStructureType sType;
- const void* pNext;
- VkBool32 computeBindingPointSupport;
- };
-
- struct VkDeviceGeneratedCommandsLimitsNVX
- {
- VkStructureType sType;
- const void* pNext;
- deUint32 maxIndirectCommandsLayoutTokenCount;
- deUint32 maxObjectEntryCounts;
- deUint32 minSequenceCountBufferOffsetAlignment;
- deUint32 minSequenceIndexBufferOffsetAlignment;
- deUint32 minCommandsTokenBufferOffsetAlignment;
- };
-
- struct VkIndirectCommandsTokenNVX
- {
- VkIndirectCommandsTokenTypeNVX tokenType;
- VkBuffer buffer;
- VkDeviceSize offset;
- };
-
- struct VkIndirectCommandsLayoutTokenNVX
- {
- VkIndirectCommandsTokenTypeNVX tokenType;
- deUint32 bindingUnit;
- deUint32 dynamicCount;
- deUint32 divisor;
- };
-
- struct VkIndirectCommandsLayoutCreateInfoNVX
- {
- VkStructureType sType;
- const void* pNext;
- VkPipelineBindPoint pipelineBindPoint;
- VkIndirectCommandsLayoutUsageFlagsNVX flags;
- deUint32 tokenCount;
- const VkIndirectCommandsLayoutTokenNVX* pTokens;
- };
-
- struct VkCmdProcessCommandsInfoNVX
- {
- VkStructureType sType;
- const void* pNext;
- VkObjectTableNVX objectTable;
- VkIndirectCommandsLayoutNVX indirectCommandsLayout;
- deUint32 indirectCommandsTokenCount;
- const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens;
- deUint32 maxSequencesCount;
- VkCommandBuffer targetCommandBuffer;
- VkBuffer sequencesCountBuffer;
- VkDeviceSize sequencesCountOffset;
- VkBuffer sequencesIndexBuffer;
- VkDeviceSize sequencesIndexOffset;
- };
-
- struct VkCmdReserveSpaceForCommandsInfoNVX
- {
- VkStructureType sType;
- const void* pNext;
- VkObjectTableNVX objectTable;
- VkIndirectCommandsLayoutNVX indirectCommandsLayout;
- deUint32 maxSequencesCount;
- };
-
- struct VkObjectTableCreateInfoNVX
- {
- VkStructureType sType;
- const void* pNext;
- deUint32 objectCount;
- const VkObjectEntryTypeNVX* pObjectEntryTypes;
- const deUint32* pObjectEntryCounts;
- const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
- deUint32 maxUniformBuffersPerDescriptor;
- deUint32 maxStorageBuffersPerDescriptor;
- deUint32 maxStorageImagesPerDescriptor;
- deUint32 maxSampledImagesPerDescriptor;
- deUint32 maxPipelineLayouts;
- };
-
- struct VkObjectTableEntryNVX
- {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- };
-
- struct VkObjectTablePipelineEntryNVX
- {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkPipeline pipeline;
- };
-
- struct VkObjectTableDescriptorSetEntryNVX
- {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkPipelineLayout pipelineLayout;
- VkDescriptorSet descriptorSet;
- };
-
- struct VkObjectTableVertexBufferEntryNVX
- {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkBuffer buffer;
- };
-
- struct VkObjectTableIndexBufferEntryNVX
- {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkBuffer buffer;
- };
-
- struct VkObjectTablePushConstantEntryNVX
- {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkPipelineLayout pipelineLayout;
- VkShaderStageFlags stageFlags;
- };
-
- struct VkPhysicalDevicePushDescriptorPropertiesKHR
- {
- VkStructureType sType;
- void* pNext;
- deUint32 maxPushDescriptors;
- };
-
- struct VkDescriptorUpdateTemplateEntryKHR
- {
- deUint32 dstBinding;
- deUint32 dstArrayElement;
- deUint32 descriptorCount;
- VkDescriptorType descriptorType;
- deUintptr offset;
- deUintptr stride;
- };
-
- struct VkDescriptorUpdateTemplateCreateInfoKHR
- {
- VkStructureType sType;
- void* pNext;
- VkDescriptorUpdateTemplateCreateFlagsKHR flags;
- deUint32 descriptorUpdateEntryCount;
- const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
- VkDescriptorUpdateTemplateTypeKHR templateType;
- VkDescriptorSetLayout descriptorSetLayout;
- VkPipelineBindPoint pipelineBindPoint;
- VkPipelineLayout pipelineLayout;
- deUint32 set;
- };
-
struct VkRefreshCycleDurationGOOGLE
{
deUint64 refreshDuration;
return res;
}
++inline VkExternalMemoryPropertiesKHX makeExternalMemoryPropertiesKHX (VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures, VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes, VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes)
++{
++ VkExternalMemoryPropertiesKHX res;
++ res.externalMemoryFeatures = externalMemoryFeatures;
++ res.exportFromImportedHandleTypes = exportFromImportedHandleTypes;
++ res.compatibleHandleTypes = compatibleHandleTypes;
++ return res;
++}
++
inline VkRefreshCycleDurationGOOGLE makeRefreshCycleDurationGOOGLE (deUint64 refreshDuration)
{
VkRefreshCycleDurationGOOGLE res;
virtual VkResult queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const = 0;
virtual VkResult createSharedSwapchainsKHR (VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const = 0;
virtual void trimCommandPoolKHR (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) const = 0;
+ virtual void cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const = 0;
+ virtual VkResult createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const = 0;
+ virtual void destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const = 0;
+ virtual void updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const = 0;
+ virtual void cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const = 0;
virtual VkResult getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const = 0;
- virtual VkResult debugMarkerSetObjectTagEXT (VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo) const = 0;
- virtual VkResult debugMarkerSetObjectNameEXT (VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo) const = 0;
- virtual void cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const = 0;
- virtual void cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer) const = 0;
- virtual void cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const = 0;
- virtual void cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
- virtual void cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
- virtual VkResult getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const = 0;
+virtual VkResult getMemoryWin32HandleKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const = 0;
++virtual VkResult getMemoryWin32HandlePropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties) const = 0;
+virtual VkResult getMemoryFdKHX (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd) const = 0;
++virtual VkResult getMemoryFdPropertiesKHX (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties) const = 0;
+virtual VkResult importSemaphoreWin32HandleKHX (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo) const = 0;
+virtual VkResult getSemaphoreWin32HandleKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, pt::Win32Handle* pHandle) const = 0;
+virtual VkResult importSemaphoreFdKHX (VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo) const = 0;
+virtual VkResult getSemaphoreFdKHX (VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd) const = 0;
- virtual void cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const = 0;
- virtual void cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) const = 0;
- virtual VkResult createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) const = 0;
- virtual void destroyIndirectCommandsLayoutNVX (VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const = 0;
- virtual VkResult createObjectTableNVX (VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) const = 0;
- virtual void destroyObjectTableNVX (VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) const = 0;
- virtual VkResult registerObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices) const = 0;
- virtual VkResult unregisterObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices) const = 0;
- virtual void cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const = 0;
- virtual VkResult createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const = 0;
- virtual void destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const = 0;
- virtual void updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const = 0;
- virtual void cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const = 0;
virtual VkResult getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const = 0;
virtual VkResult getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, deUint32* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const = 0;
virtual VkResult createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const = 0;
virtual void destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const = 0;
virtual void debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage) const = 0;
- virtual VkResult getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const = 0;
+virtual void getPhysicalDeviceExternalBufferPropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties) const = 0;
+virtual void getPhysicalDeviceExternalSemaphorePropertiesKHX (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties) const = 0;
- virtual void getPhysicalDeviceGeneratedCommandsPropertiesNVX (VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) const = 0;
--- /dev/null
- if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageUniformBufferBlock16 == VK_FALSE)
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Utilities for Vulkan SPIR-V assembly tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktSpvAsmUtils.hpp"
+
+#include "deMemory.h"
+#include "deSTLUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkRefUtil.hpp"
+
+namespace vkt
+{
+namespace SpirVAssembly
+{
+
+using namespace vk;
+
+namespace
+{
+
+VkPhysicalDeviceFeatures filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures)
+{
+ VkPhysicalDeviceFeatures enabledDeviceFeatures = deviceFeatures;
+
+ // Disable robustness by default, as it has an impact on performance on some HW.
+ enabledDeviceFeatures.robustBufferAccess = false;
+
+ return enabledDeviceFeatures;
+}
+
+VkPhysicalDevice16BitStorageFeaturesKHR querySupported16BitStorageFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
+{
+ VkPhysicalDevice16BitStorageFeaturesKHR extensionFeatures =
+ {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, // sType
+ DE_NULL, // pNext
+ false, // storageUniformBufferBlock16
+ false, // storageUniform16
+ false, // storagePushConstant16
+ false, // storageInputOutput16
+ };
+ VkPhysicalDeviceFeatures2KHR features;
+
+ deMemset(&features, 0, sizeof(features));
+ features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ features.pNext = &extensionFeatures;
+
+ // Call the getter only if supported. Otherwise above "zero" defaults are used
+ if (de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2"))
+ {
+ vki.getPhysicalDeviceFeatures2KHR(device, &features);
+ }
+
+ return extensionFeatures;
+}
+
+} // anonymous
+
+bool is16BitStorageFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, Extension16BitStorageFeatures toCheck)
+{
+ VkPhysicalDevice16BitStorageFeaturesKHR extensionFeatures = querySupported16BitStorageFeatures(vki, device, instanceExtensions);
+
- if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM) != 0 && extensionFeatures.storageUniform16 == VK_FALSE)
++ if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageBuffer16BitAccess == VK_FALSE)
+ return false;
+
++ if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM) != 0 && extensionFeatures.uniformAndStorageBuffer16BitAccess == VK_FALSE)
+ return false;
+
+ if ((toCheck & EXT16BITSTORAGEFEATURES_PUSH_CONSTANT) != 0 && extensionFeatures.storagePushConstant16 == VK_FALSE)
+ return false;
+
+ if ((toCheck & EXT16BITSTORAGEFEATURES_INPUT_OUTPUT) != 0 && extensionFeatures.storageInputOutput16 == VK_FALSE)
+ return false;
+
+ return true;
+}
+
+Move<VkDevice> createDeviceWithExtensions (Context& context,
+ const deUint32 queueFamilyIndex,
+ const std::vector<std::string>& supportedExtensions,
+ const std::vector<std::string>& requiredExtensions)
+{
+ const InstanceInterface& vki = context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+ std::vector<const char*> extensions (requiredExtensions.size());
+ bool requires16BitStorageExtension = false;
+
+ for (deUint32 extNdx = 0; extNdx < requiredExtensions.size(); ++extNdx)
+ {
+ const std::string& ext = requiredExtensions[extNdx];
+
+ // Check that all required extensions are supported first.
+ if (!de::contains(supportedExtensions.begin(), supportedExtensions.end(), ext))
+ {
+ TCU_THROW(NotSupportedError, (std::string("Device extension not supported: ") + ext).c_str());
+ }
+
+ if (ext == "VK_KHR_16bit_storage")
+ {
+ requires16BitStorageExtension = true;
+ }
+
+ extensions[extNdx] = ext.c_str();
+ }
+
+ // For the 16bit storage extension, we have four features to test. Requesting all features supported.
+ // Note that we don't throw NotImplemented errors here if a specific feature is not supported;
+ // that should be done when actually trying to use that specific feature.
+ VkPhysicalDevice16BitStorageFeaturesKHR ext16BitStorageFeatures = querySupported16BitStorageFeatures(vki, physicalDevice, context.getInstanceExtensions());
+
+ const float queuePriorities[] = { 1.0f };
+ const VkDeviceQueueCreateInfo queueInfos[] =
+ {
+ {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
+ (VkDeviceQueueCreateFlags)0,
+ queueFamilyIndex,
+ DE_LENGTH_OF_ARRAY(queuePriorities),
+ &queuePriorities[0]
+ }
+ };
+ const VkPhysicalDeviceFeatures features = filterDefaultDeviceFeatures(getPhysicalDeviceFeatures(vki, physicalDevice));
+ const VkDeviceCreateInfo deviceParams =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+ (requires16BitStorageExtension ? &ext16BitStorageFeatures : DE_NULL),
+ (VkDeviceCreateFlags)0,
+ DE_LENGTH_OF_ARRAY(queueInfos),
+ &queueInfos[0],
+ 0u,
+ DE_NULL,
+ (deUint32)extensions.size(),
+ &extensions[0],
+ &features
+ };
+
+ return vk::createDevice(vki, physicalDevice, &deviceParams);
+}
+
+Allocator* createAllocator (const InstanceInterface& instanceInterface, const VkPhysicalDevice physicalDevice, const DeviceInterface& deviceInterface, const VkDevice device)
+{
+ const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(instanceInterface, physicalDevice);
+
+ // \todo [2015-07-24 jarkko] support allocator selection/configuration from command line (or compile time)
+ return new SimpleAllocator(deviceInterface, device, memoryProperties);
+}
+
+} // SpirVAssembly
+} // vkt
--- /dev/null
- || (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV) == 0)
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2016 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Synchronization tests for resources shared between instances.
+ *//*--------------------------------------------------------------------*/
+
+#include "vktSynchronizationCrossInstanceSharingTests.hpp"
+
+#include "vkDeviceUtil.hpp"
+#include "vkPlatform.hpp"
+
+#include "vktTestCaseUtil.hpp"
+
+#include "vktSynchronizationUtil.hpp"
+#include "vktSynchronizationOperation.hpp"
+#include "vktSynchronizationOperationTestData.hpp"
+#include "vktExternalMemoryUtil.hpp"
+
+#include "tcuResultCollector.hpp"
+#include "tcuTestLog.hpp"
+
+using tcu::TestLog;
+using namespace vkt::ExternalMemoryUtil;
+
+namespace vkt
+{
+namespace synchronization
+{
+namespace
+{
+
+struct TestConfig
+{
+ TestConfig (const ResourceDescription& resource_,
+ OperationName writeOp_,
+ OperationName readOp_,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX memoryHandleType_,
+ vk::VkExternalSemaphoreHandleTypeFlagBitsKHX semaphoreHandleType_)
+ : resource (resource_)
+ , writeOp (writeOp_)
+ , readOp (readOp_)
+ , memoryHandleType (memoryHandleType_)
+ , semaphoreHandleType (semaphoreHandleType_)
+ {
+ }
+
+ const ResourceDescription resource;
+ const OperationName writeOp;
+ const OperationName readOp;
+ const vk::VkExternalMemoryHandleTypeFlagBitsKHX memoryHandleType;
+ const vk::VkExternalSemaphoreHandleTypeFlagBitsKHX semaphoreHandleType;
+};
+
+bool checkQueueFlags (vk::VkQueueFlags availableFlags, const vk::VkQueueFlags neededFlags)
+{
+ if ((availableFlags & (vk::VK_QUEUE_GRAPHICS_BIT | vk::VK_QUEUE_COMPUTE_BIT)) != 0)
+ availableFlags |= vk::VK_QUEUE_TRANSFER_BIT;
+
+ return (availableFlags & neededFlags) != 0;
+}
+
+class SimpleAllocation : public vk::Allocation
+{
+public:
+ SimpleAllocation (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ const vk::VkDeviceMemory memory);
+ ~SimpleAllocation (void);
+
+private:
+ const vk::DeviceInterface& m_vkd;
+ const vk::VkDevice m_device;
+};
+
+SimpleAllocation::SimpleAllocation (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ const vk::VkDeviceMemory memory)
+ : Allocation (memory, 0, DE_NULL)
+ , m_vkd (vkd)
+ , m_device (device)
+{
+}
+
+SimpleAllocation::~SimpleAllocation (void)
+{
+ m_vkd.freeMemory(m_device, getMemory(), DE_NULL);
+}
+
+class DeviceId
+{
+public:
+ DeviceId (deUint32 vendorId,
+ deUint32 driverVersion,
+ const deUint8 driverUUID[VK_UUID_SIZE],
+ const deUint8 deviceUUID[VK_UUID_SIZE]);
+
+ bool operator== (const DeviceId& other) const;
+ bool operator|= (const DeviceId& other) const;
+
+private:
+ const deUint32 m_vendorId;
+ const deUint32 m_driverVersion;
+ deUint8 m_driverUUID[VK_UUID_SIZE];
+ deUint8 m_deviceUUID[VK_UUID_SIZE];
+};
+
+DeviceId::DeviceId (deUint32 vendorId,
+ deUint32 driverVersion,
+ const deUint8 driverUUID[VK_UUID_SIZE],
+ const deUint8 deviceUUID[VK_UUID_SIZE])
+ : m_vendorId (vendorId)
+ , m_driverVersion (driverVersion)
+{
+ deMemcpy(m_driverUUID, driverUUID, sizeof(m_driverUUID));
+ deMemcpy(m_deviceUUID, deviceUUID, sizeof(m_deviceUUID));
+}
+
+bool DeviceId::operator== (const DeviceId& other) const
+{
+ if (this == &other)
+ return true;
+
+ if (m_vendorId != other.m_vendorId)
+ return false;
+
+ if (m_driverVersion != other.m_driverVersion)
+ return false;
+
+ if (deMemCmp(m_driverUUID, other.m_driverUUID, sizeof(m_driverUUID)) != 0)
+ return false;
+
+ return deMemCmp(m_deviceUUID, other.m_deviceUUID, sizeof(m_deviceUUID)) == 0;
+}
+
+DeviceId getDeviceId (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice physicalDevice)
+{
+ vk::VkPhysicalDeviceIDPropertiesKHX propertiesId;
+ vk::VkPhysicalDeviceProperties2KHR properties;
+
+ deMemset(&properties, 0, sizeof(properties));
+ deMemset(&propertiesId, 0, sizeof(propertiesId));
+
+ propertiesId.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX;
+
+ properties.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ properties.pNext = &propertiesId;
+
+ vki.getPhysicalDeviceProperties2KHR(physicalDevice, &properties);
+
+ return DeviceId(properties.properties.vendorID, properties.properties.driverVersion, propertiesId.driverUUID, propertiesId.deviceUUID);
+}
+
+vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp)
+{
+ try
+ {
+ std::vector<std::string> extensions;
+
+ extensions.push_back("VK_KHR_get_physical_device_properties2");
+
+ extensions.push_back("VK_KHX_external_semaphore_capabilities");
+ extensions.push_back("VK_KHX_external_memory_capabilities");
+
+ return vk::createDefaultInstance(vkp, std::vector<std::string>(), extensions);
+ }
+ catch (const vk::Error& error)
+ {
+ if (error.getError() == vk::VK_ERROR_EXTENSION_NOT_PRESENT)
+ TCU_THROW(NotSupportedError, "Required external memory extensions not supported by the instance");
+ else
+ throw;
+ }
+}
+
+vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface& vki,
+ vk::VkInstance instance,
+ const tcu::CommandLine& cmdLine)
+{
+ return vk::chooseDevice(vki, instance, cmdLine);
+}
+
+vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface& vki, vk::VkInstance instance, const DeviceId& deviceId)
+{
+ const std::vector<vk::VkPhysicalDevice> devices (vk::enumeratePhysicalDevices(vki, instance));
+
+ for (size_t deviceNdx = 0; deviceNdx < devices.size(); deviceNdx++)
+ {
+ if (deviceId == getDeviceId(vki, devices[deviceNdx]))
+ return devices[deviceNdx];
+ }
+
+ TCU_FAIL("No matching device found");
+
+ return (vk::VkPhysicalDevice)0;
+}
+
+vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice physicalDevice,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX memoryHandleType,
+ vk::VkExternalSemaphoreHandleTypeFlagBitsKHX semaphoreHandleType)
+{
+ const float priority = 0.0f;
+ const std::vector<vk::VkQueueFamilyProperties> queueFamilyProperties = vk::getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
+ std::vector<deUint32> queueFamilyIndices (queueFamilyProperties.size(), 0xFFFFFFFFu);
+ std::vector<const char*> extensions;
+
+ extensions.push_back("VK_KHX_external_semaphore");
+ extensions.push_back("VK_KHX_external_memory");
+
+ if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX)
+ {
+ extensions.push_back("VK_KHX_external_semaphore_fd");
+ extensions.push_back("VK_KHX_external_memory_fd");
+ }
+
+ if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX)
+ {
+ extensions.push_back("VK_KHX_external_semaphore_win32");
+ extensions.push_back("VK_KHX_external_memory_win32");
+ }
+
+ try
+ {
+ std::vector<vk::VkDeviceQueueCreateInfo> queues;
+
+ for (size_t ndx = 0; ndx < queueFamilyProperties.size(); ndx++)
+ {
+ const vk::VkDeviceQueueCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+ DE_NULL,
+ 0u,
+
+ (deUint32)ndx,
+ 1u,
+ &priority
+ };
+
+ queues.push_back(createInfo);
+ }
+
+ const vk::VkDeviceCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+ DE_NULL,
+ 0u,
+
+ (deUint32)queues.size(),
+ &queues[0],
+
+ 0u,
+ DE_NULL,
+
+ (deUint32)extensions.size(),
+ extensions.empty() ? DE_NULL : &extensions[0],
+ 0u
+ };
+
+ return vk::createDevice(vki, physicalDevice, &createInfo);
+ }
+ catch (const vk::Error& error)
+ {
+ if (error.getError() == vk::VK_ERROR_EXTENSION_NOT_PRESENT)
+ TCU_THROW(NotSupportedError, "Required extensions not supported");
+ else
+ throw;
+ }
+}
+
+vk::VkQueue getQueue (const vk::DeviceInterface& vkd,
+ const vk::VkDevice device,
+ deUint32 familyIndex)
+{
+ vk::VkQueue queue;
+
+ vkd.getDeviceQueue(device, familyIndex, 0u, &queue);
+
+ return queue;
+}
+
+vk::Move<vk::VkCommandPool> createCommandPool (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ deUint32 queueFamilyIndex)
+{
+ const vk::VkCommandPoolCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+ DE_NULL,
+
+ 0u,
+ queueFamilyIndex
+ };
+
+ return vk::createCommandPool(vkd, device, &createInfo);
+}
+
+vk::Move<vk::VkCommandBuffer> createCommandBuffer (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkCommandPool commandPool)
+{
+ const vk::VkCommandBufferLevel level = vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+ const vk::VkCommandBufferAllocateInfo allocateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+ DE_NULL,
+
+ commandPool,
+ level,
+ 1u
+ };
+
+ return vk::allocateCommandBuffer(vkd, device, &allocateInfo);
+}
+
+de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkBuffer buffer,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX externalType)
+{
+ const vk::VkMemoryRequirements requirements = vk::getBufferMemoryRequirements(vkd, device, buffer);
+
+ vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, requirements, externalType);
+ VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
+
+ return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
+}
+
+de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkImage image,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX externalType)
+{
+ const vk::VkMemoryRequirements requirements = vk::getImageMemoryRequirements(vkd, device, image);
+
+ vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, requirements, externalType);
+ VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
+
+ return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
+}
+
+de::MovePtr<Resource> createResource (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ const ResourceDescription& resourceDesc,
+ const std::vector<deUint32>& queueFamilyIndices,
+ const OperationSupport& readOp,
+ const OperationSupport& writeOp,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX externalType)
+{
+ if (resourceDesc.type == RESOURCE_TYPE_IMAGE)
+ {
+ const vk::VkExtent3D extent =
+ {
+ (deUint32)resourceDesc.size.x(),
+ de::max(1u, (deUint32)resourceDesc.size.y()),
+ de::max(1u, (deUint32)resourceDesc.size.z())
+ };
+ const vk::VkImageSubresourceRange subresourceRange =
+ {
+ resourceDesc.imageAspect,
+ 0u,
+ 1u,
+ 0u,
+ 1u
+ };
+ const vk::VkImageSubresourceLayers subresourceLayers =
+ {
+ resourceDesc.imageAspect,
+ 0u,
+ 0u,
+ 1u
+ };
+ const vk::VkExternalMemoryImageCreateInfoKHX externalInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX,
+ DE_NULL,
+ (vk::VkExternalMemoryHandleTypeFlagsKHX)externalType
+ };
+ const vk::VkImageCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+ &externalInfo,
+ 0u,
+
+ resourceDesc.imageType,
+ resourceDesc.imageFormat,
+ extent,
+ 1u,
+ 1u,
+ vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VK_IMAGE_TILING_OPTIMAL,
+ readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(),
+ vk::VK_SHARING_MODE_EXCLUSIVE,
+
+ (deUint32)queueFamilyIndices.size(),
+ &queueFamilyIndices[0],
+ vk::VK_IMAGE_LAYOUT_UNDEFINED
+ };
+
+ vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &createInfo);
+ de::MovePtr<vk::Allocation> allocation = allocateAndBindMemory(vkd, device, *image, externalType);
+
+ return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
+ }
+ else
+ {
+ const vk::VkDeviceSize offset = 0u;
+ const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
+ const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
+ const vk:: VkExternalMemoryBufferCreateInfoKHX externalInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX,
+ DE_NULL,
+ (vk::VkExternalMemoryHandleTypeFlagsKHX)externalType
+ };
+ const vk::VkBufferCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+ &externalInfo,
+ 0u,
+
+ size,
+ usage,
+ vk::VK_SHARING_MODE_EXCLUSIVE,
+ (deUint32)queueFamilyIndices.size(),
+ &queueFamilyIndices[0]
+ };
+ vk::Move<vk::VkBuffer> buffer = vk::createBuffer(vkd, device, &createInfo);
+ de::MovePtr<vk::Allocation> allocation = allocateAndBindMemory(vkd, device, *buffer, externalType);
+
+ return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
+ }
+}
+
+de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkBuffer buffer,
+ NativeHandle& nativeHandle,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX externalType)
+{
+ const vk::VkMemoryRequirements requirements = vk::getBufferMemoryRequirements(vkd, device, buffer);
+
+ vk::Move<vk::VkDeviceMemory> memory = importMemory(vkd, device, requirements, externalType, nativeHandle);
+ VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
+
+ return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
+}
+
+de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkImage image,
+ NativeHandle& nativeHandle,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX externalType)
+{
+ const vk::VkMemoryRequirements requirements = vk::getImageMemoryRequirements(vkd, device, image);
+
+ vk::Move<vk::VkDeviceMemory> memory = importMemory(vkd, device, requirements, externalType, nativeHandle);
+ VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
+
+ return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
+}
+
+de::MovePtr<Resource> importResource (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ const ResourceDescription& resourceDesc,
+ const std::vector<deUint32>& queueFamilyIndices,
+ const OperationSupport& readOp,
+ const OperationSupport& writeOp,
+ NativeHandle& nativeHandle,
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX externalType)
+{
+ if (resourceDesc.type == RESOURCE_TYPE_IMAGE)
+ {
+ const vk::VkExtent3D extent =
+ {
+ (deUint32)resourceDesc.size.x(),
+ de::max(1u, (deUint32)resourceDesc.size.y()),
+ de::max(1u, (deUint32)resourceDesc.size.z())
+ };
+ const vk::VkImageSubresourceRange subresourceRange =
+ {
+ resourceDesc.imageAspect,
+ 0u,
+ 1u,
+ 0u,
+ 1u
+ };
+ const vk::VkImageSubresourceLayers subresourceLayers =
+ {
+ resourceDesc.imageAspect,
+ 0u,
+ 0u,
+ 1u
+ };
+ const vk:: VkExternalMemoryImageCreateInfoKHX externalInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX,
+ DE_NULL,
+ (vk::VkExternalMemoryHandleTypeFlagsKHX)externalType
+ };
+ const vk::VkImageCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+ &externalInfo,
+ 0u,
+
+ resourceDesc.imageType,
+ resourceDesc.imageFormat,
+ extent,
+ 1u,
+ 1u,
+ vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VK_IMAGE_TILING_OPTIMAL,
+ readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(),
+ vk::VK_SHARING_MODE_EXCLUSIVE,
+
+ (deUint32)queueFamilyIndices.size(),
+ &queueFamilyIndices[0],
+ vk::VK_IMAGE_LAYOUT_UNDEFINED
+ };
+
+ vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &createInfo);
+ de::MovePtr<vk::Allocation> allocation = importAndBindMemory(vkd, device, *image, nativeHandle, externalType);
+
+ return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
+ }
+ else
+ {
+ const vk::VkDeviceSize offset = 0u;
+ const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
+ const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
+ const vk:: VkExternalMemoryBufferCreateInfoKHX externalInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX,
+ DE_NULL,
+ (vk::VkExternalMemoryHandleTypeFlagsKHX)externalType
+ };
+ const vk::VkBufferCreateInfo createInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+ &externalInfo,
+ 0u,
+
+ size,
+ usage,
+ vk::VK_SHARING_MODE_EXCLUSIVE,
+ (deUint32)queueFamilyIndices.size(),
+ &queueFamilyIndices[0]
+ };
+ vk::Move<vk::VkBuffer> buffer = vk::createBuffer(vkd, device, &createInfo);
+ de::MovePtr<vk::Allocation> allocation = importAndBindMemory(vkd, device, *buffer, nativeHandle, externalType);
+
+ return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
+ }
+}
+
+void recordWriteBarrier (const vk::DeviceInterface& vkd,
+ vk::VkCommandBuffer commandBuffer,
+ const Resource& resource,
+ const SyncInfo& writeSync,
+ deUint32 writeQueueFamilyIndex,
+ const SyncInfo& readSync)
+{
+ const vk::VkPipelineStageFlags srcStageMask = writeSync.stageMask;
+ const vk::VkAccessFlags srcAccessMask = writeSync.accessMask;
+
+ const vk::VkPipelineStageFlags dstStageMask = readSync.stageMask;
+ const vk::VkAccessFlags dstAccessMask = readSync.accessMask;
+
+ const vk::VkDependencyFlags dependencyFlags = 0;
+
+ if (resource.getType() == RESOURCE_TYPE_IMAGE)
+ {
+ const vk::VkImageMemoryBarrier barrier =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+ DE_NULL,
+
+ srcAccessMask,
+ dstAccessMask,
+
+ writeSync.imageLayout,
+ readSync.imageLayout,
+
+ writeQueueFamilyIndex,
+ VK_QUEUE_FAMILY_EXTERNAL_KHX,
+
+ resource.getImage().handle,
+ resource.getImage().subresourceRange
+ };
+
+ vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 0u, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1u, (const vk::VkImageMemoryBarrier*)&barrier);
+ }
+ else
+ {
+ const vk::VkBufferMemoryBarrier barrier =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+
+ srcAccessMask,
+ dstAccessMask,
+
+ writeQueueFamilyIndex,
+ VK_QUEUE_FAMILY_EXTERNAL_KHX,
+
+ resource.getBuffer().handle,
+ 0u,
+ VK_WHOLE_SIZE
+ };
+
+ vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 1u, (const vk::VkBufferMemoryBarrier*)&barrier, 0u, (const vk::VkImageMemoryBarrier*)DE_NULL);
+ }
+}
+
+void recordReadBarrier (const vk::DeviceInterface& vkd,
+ vk::VkCommandBuffer commandBuffer,
+ const Resource& resource,
+ const SyncInfo& writeSync,
+ const SyncInfo& readSync,
+ deUint32 readQueueFamilyIndex)
+{
+ const vk::VkPipelineStageFlags srcStageMask = readSync.stageMask;
+ const vk::VkAccessFlags srcAccessMask = readSync.accessMask;
+
+ const vk::VkPipelineStageFlags dstStageMask = readSync.stageMask;
+ const vk::VkAccessFlags dstAccessMask = readSync.accessMask;
+
+ const vk::VkDependencyFlags dependencyFlags = 0;
+
+ if (resource.getType() == RESOURCE_TYPE_IMAGE)
+ {
+ const vk::VkImageMemoryBarrier barrier =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+ DE_NULL,
+
+ srcAccessMask,
+ dstAccessMask,
+
+ writeSync.imageLayout,
+ readSync.imageLayout,
+
+ VK_QUEUE_FAMILY_EXTERNAL_KHX,
+ readQueueFamilyIndex,
+
+ resource.getImage().handle,
+ resource.getImage().subresourceRange
+ };
+
+ vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 0u, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1u, (const vk::VkImageMemoryBarrier*)&barrier);
+ }
+ else
+ {
+ const vk::VkBufferMemoryBarrier barrier =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+
+ srcAccessMask,
+ dstAccessMask,
+
+ VK_QUEUE_FAMILY_EXTERNAL_KHX,
+ readQueueFamilyIndex,
+
+ resource.getBuffer().handle,
+ 0u,
+ VK_WHOLE_SIZE
+ };
+
+ vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 1u, (const vk::VkBufferMemoryBarrier*)&barrier, 0u, (const vk::VkImageMemoryBarrier*)DE_NULL);
+ }
+}
+
+std::vector<deUint32> getFamilyIndices (const std::vector<vk::VkQueueFamilyProperties>& properties)
+{
+ std::vector<deUint32> indices (properties.size(), 0);
+
+ for (deUint32 ndx = 0; ndx < properties.size(); ndx++)
+ indices[ndx] = ndx;
+
+ return indices;
+}
+
+class SharingTestInstance : public TestInstance
+{
+public:
+ SharingTestInstance (Context& context,
+ TestConfig config);
+
+ virtual tcu::TestStatus iterate (void);
+
+private:
+ const TestConfig m_config;
+ const de::UniquePtr<OperationSupport> m_supportWriteOp;
+ const de::UniquePtr<OperationSupport> m_supportReadOp;
+
+ const vk::Unique<vk::VkInstance> m_instanceA;
+
+ const vk::InstanceDriver m_vkiA;
+ const vk::VkPhysicalDevice m_physicalDeviceA;
+ const std::vector<vk::VkQueueFamilyProperties> m_queueFamiliesA;
+ const std::vector<deUint32> m_queueFamilyIndicesA;
+
+ const vk::Unique<vk::VkDevice> m_deviceA;
+ const vk::DeviceDriver m_vkdA;
+
+ const vk::Unique<vk::VkInstance> m_instanceB;
+ const vk::InstanceDriver m_vkiB;
+ const vk::VkPhysicalDevice m_physicalDeviceB;
+ const std::vector<vk::VkQueueFamilyProperties> m_queueFamiliesB;
+ const std::vector<deUint32> m_queueFamilyIndicesB;
+ const vk::Unique<vk::VkDevice> m_deviceB;
+ const vk::DeviceDriver m_vkdB;
+
+ const vk::VkExternalSemaphoreHandleTypeFlagBitsKHX m_semaphoreHandleType;
+ const vk::VkExternalMemoryHandleTypeFlagBitsKHX m_memoryHandleType;
+
+ // \todo Should this be moved to the group same way as in the other tests?
+ PipelineCacheData m_pipelineCacheData;
+ tcu::ResultCollector m_resultCollector;
+ size_t m_queueANdx;
+ size_t m_queueBNdx;
+};
+
+SharingTestInstance::SharingTestInstance (Context& context,
+ TestConfig config)
+ : TestInstance (context)
+ , m_config (config)
+ , m_supportWriteOp (makeOperationSupport(config.writeOp, config.resource))
+ , m_supportReadOp (makeOperationSupport(config.readOp, config.resource))
+
+ , m_instanceA (createInstance(context.getPlatformInterface()))
+
+ , m_vkiA (context.getPlatformInterface(), *m_instanceA)
+ , m_physicalDeviceA (getPhysicalDevice(m_vkiA, *m_instanceA, context.getTestContext().getCommandLine()))
+ , m_queueFamiliesA (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiA, m_physicalDeviceA))
+ , m_queueFamilyIndicesA (getFamilyIndices(m_queueFamiliesA))
+ , m_deviceA (createDevice(m_vkiA, m_physicalDeviceA, m_config.memoryHandleType, m_config.semaphoreHandleType))
+ , m_vkdA (m_vkiA, *m_deviceA)
+
+ , m_instanceB (createInstance(context.getPlatformInterface()))
+
+ , m_vkiB (context.getPlatformInterface(), *m_instanceB)
+ , m_physicalDeviceB (getPhysicalDevice(m_vkiB, *m_instanceB, getDeviceId(m_vkiA, m_physicalDeviceA)))
+ , m_queueFamiliesB (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiB, m_physicalDeviceB))
+ , m_queueFamilyIndicesB (getFamilyIndices(m_queueFamiliesB))
+ , m_deviceB (createDevice(m_vkiB, m_physicalDeviceB, m_config.memoryHandleType, m_config.semaphoreHandleType))
+ , m_vkdB (m_vkiB, *m_deviceB)
+
+ , m_semaphoreHandleType (m_config.semaphoreHandleType)
+ , m_memoryHandleType (m_config.memoryHandleType)
+
+ , m_resultCollector (context.getTestContext().getLog())
+ , m_queueANdx (0)
+ , m_queueBNdx (0)
+{
+ TestLog& log = m_context.getTestContext().getLog();
+
+ // Check resource support
+ if (m_config.resource.type == RESOURCE_TYPE_IMAGE)
+ {
+ const vk::VkPhysicalDeviceExternalImageFormatInfoKHX externalInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX,
+ DE_NULL,
+ m_memoryHandleType
+ };
+ const vk::VkPhysicalDeviceImageFormatInfo2KHR imageFormatInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+ &externalInfo,
+ m_config.resource.imageFormat,
+ m_config.resource.imageType,
+ vk::VK_IMAGE_TILING_OPTIMAL,
+ m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
+ 0u
+ };
+ vk::VkExternalImageFormatPropertiesKHX externalProperties =
+ {
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX,
+ DE_NULL,
+ { 0u, 0u, 0u }
+ };
+ vk::VkImageFormatProperties2KHR formatProperties =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
+ &externalProperties,
+ {
+ { 0u, 0u, 0u },
+ 0u,
+ 0u,
+ 0u,
+ 0u,
+ }
+ };
+ VK_CHECK(m_vkiA.getPhysicalDeviceImageFormatProperties2KHR(m_physicalDeviceA, &imageFormatInfo, &formatProperties));
+
+ // \todo How to log this nicely?
+ log << TestLog::Message << "External image format properties: " << imageFormatInfo << "\n"<< externalProperties << TestLog::EndMessage;
+
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX) == 0)
+ TCU_THROW(NotSupportedError, "Exporting image resource not supported");
+
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX) == 0)
+ TCU_THROW(NotSupportedError, "Importing image resource not supported");
+ }
+ else
+ {
+ const vk::VkPhysicalDeviceExternalBufferInfoKHX info =
+ {
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX,
+ DE_NULL,
+
+ 0u,
+ m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
+ m_memoryHandleType
+ };
+ vk::VkExternalBufferPropertiesKHX properties =
+ {
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX,
+ DE_NULL,
+ { 0u, 0u, 0u}
+ };
+ m_vkiA.getPhysicalDeviceExternalBufferPropertiesKHX(m_physicalDeviceA, &info, &properties);
+
+ log << TestLog::Message << "External buffer properties: " << info << "\n" << properties << TestLog::EndMessage;
+
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX) == 0
++ || (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX) == 0)
+ TCU_THROW(NotSupportedError, "Exporting and importing memory type not supported");
+ }
+
+ // Check semaphore support
+ {
+ const vk::VkPhysicalDeviceExternalSemaphoreInfoKHX info =
+ {
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX,
+ DE_NULL,
+ m_semaphoreHandleType
+ };
+ vk::VkExternalSemaphorePropertiesKHX properties;
+
+ m_vkiA.getPhysicalDeviceExternalSemaphorePropertiesKHX(m_physicalDeviceA, &info, &properties);
+
+ log << TestLog::Message << info << "\n" << properties << TestLog::EndMessage;
+
+ if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX) == 0
+ || (properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX) == 0)
+ TCU_THROW(NotSupportedError, "Exporting and importing semaphore type not supported");
+ }
+}
+
+tcu::TestStatus SharingTestInstance::iterate (void)
+{
+ TestLog& log (m_context.getTestContext().getLog());
+
+ try
+ {
+ const deUint32 queueFamilyA = (deUint32)m_queueANdx;
+ const deUint32 queueFamilyB = (deUint32)m_queueBNdx;
+
+ const tcu::ScopedLogSection queuePairSection (log,
+ "WriteQueue-" + de::toString(queueFamilyA) + "-ReadQueue-" + de::toString(queueFamilyB),
+ "WriteQueue-" + de::toString(queueFamilyA) + "-ReadQueue-" + de::toString(queueFamilyB));
+
+ const vk::Unique<vk::VkSemaphore> semaphoreA (createExportableSemaphore(m_vkdA, *m_deviceA, m_semaphoreHandleType));
+ const vk::Unique<vk::VkSemaphore> semaphoreB (createSemaphore(m_vkdB, *m_deviceB));
+
+ const vk::VkQueue queueA (getQueue(m_vkdA, *m_deviceA, queueFamilyA));
+ const vk::Unique<vk::VkCommandPool> commandPoolA (createCommandPool(m_vkdA, *m_deviceA, queueFamilyA));
+ const vk::Unique<vk::VkCommandBuffer> commandBufferA (createCommandBuffer(m_vkdA, *m_deviceA, *commandPoolA));
+ vk::SimpleAllocator allocatorA (m_vkdA, *m_deviceA, vk::getPhysicalDeviceMemoryProperties(m_vkiA, m_physicalDeviceA));
+ const std::vector<std::string> deviceExtensionsA;
+ OperationContext operationContextA (m_vkiA, m_vkdA, m_physicalDeviceA, *m_deviceA, allocatorA, deviceExtensionsA, m_context.getBinaryCollection(), m_pipelineCacheData);
+
+ if (!checkQueueFlags(m_queueFamiliesA[m_queueANdx].queueFlags , m_supportWriteOp->getQueueFlags(operationContextA)))
+ TCU_THROW(NotSupportedError, "Operation not supported by the source queue");
+
+ const de::UniquePtr<Resource> resourceA (createResource(m_vkdA, *m_deviceA, m_config.resource, m_queueFamilyIndicesA, *m_supportReadOp, *m_supportWriteOp, m_memoryHandleType));
+
+ const vk::VkQueue queueB (getQueue(m_vkdB, *m_deviceB, queueFamilyB));
+ const vk::Unique<vk::VkCommandPool> commandPoolB (createCommandPool(m_vkdB, *m_deviceB, queueFamilyB));
+ const vk::Unique<vk::VkCommandBuffer> commandBufferB (createCommandBuffer(m_vkdB, *m_deviceB, *commandPoolB));
+ vk::SimpleAllocator allocatorB (m_vkdB, *m_deviceB, vk::getPhysicalDeviceMemoryProperties(m_vkiB, m_physicalDeviceB));
+ const std::vector<std::string> deviceExtensionsB;
+ OperationContext operationContextB (m_vkiB, m_vkdB, m_physicalDeviceB, *m_deviceB, allocatorB, deviceExtensionsB, m_context.getBinaryCollection(), m_pipelineCacheData);
+
+ if (!checkQueueFlags(m_queueFamiliesB[m_queueBNdx].queueFlags , m_supportReadOp->getQueueFlags(operationContextB)))
+ TCU_THROW(NotSupportedError, "Operation not supported by the destination queue");
+
+ NativeHandle nativeMemoryHandle;
+ getMemoryNative(m_vkdA, *m_deviceA, resourceA->getMemory(), m_memoryHandleType, nativeMemoryHandle);
+
+ const de::UniquePtr<Resource> resourceB (importResource(m_vkdB, *m_deviceB, m_config.resource, m_queueFamilyIndicesB, *m_supportReadOp, *m_supportWriteOp, nativeMemoryHandle, m_memoryHandleType));
+
+ const de::UniquePtr<Operation> writeOp (m_supportWriteOp->build(operationContextA, *resourceA));
+ const de::UniquePtr<Operation> readOp (m_supportReadOp->build(operationContextB, *resourceB));
+
+ const SyncInfo writeSync = writeOp->getSyncInfo();
+ const SyncInfo readSync = readOp->getSyncInfo();
+
+ if (getHandleTypePermanence(m_semaphoreHandleType) == PERMANENCE_PERMANENT)
+ {
+ NativeHandle nativeSemaphoreHandle;
+
+ getSemaphoreNative(m_vkdA, *m_deviceA, *semaphoreA, m_semaphoreHandleType, nativeSemaphoreHandle);
+ importSemaphore(m_vkdB, *m_deviceB, *semaphoreB, m_semaphoreHandleType, nativeSemaphoreHandle);
+ }
+
+ beginCommandBuffer(m_vkdA, *commandBufferA);
+ writeOp->recordCommands(*commandBufferA);
+ recordWriteBarrier(m_vkdA, *commandBufferA, *resourceA, writeSync, queueFamilyA, readSync);
+ endCommandBuffer(m_vkdA, *commandBufferA);
+
+ beginCommandBuffer(m_vkdB, *commandBufferB);
+ recordReadBarrier(m_vkdB, *commandBufferB, *resourceB, writeSync, readSync, queueFamilyB);
+ readOp->recordCommands(*commandBufferB);
+ endCommandBuffer(m_vkdB, *commandBufferB);
+
+ {
+ const vk::VkCommandBuffer commandBuffer = *commandBufferA;
+ const vk::VkSemaphore semaphore = *semaphoreA;
+ const vk::VkSubmitInfo submitInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
+ DE_NULL,
+
+ 0u,
+ DE_NULL,
+ DE_NULL,
+
+ 1u,
+ &commandBuffer,
+ 1u,
+ &semaphore
+ };
+
+ VK_CHECK(m_vkdA.queueSubmit(queueA, 1u, &submitInfo, DE_NULL));
+
+ if (getHandleTypePermanence(m_semaphoreHandleType) == PERMANENCE_TEMPORARY)
+ {
+ NativeHandle nativeSemaphoreHandle;
+
+ getSemaphoreNative(m_vkdA, *m_deviceA, *semaphoreA, m_semaphoreHandleType, nativeSemaphoreHandle);
+ importSemaphore(m_vkdB, *m_deviceB, *semaphoreB, m_semaphoreHandleType, nativeSemaphoreHandle);
+ }
+ }
+ {
+ const vk::VkCommandBuffer commandBuffer = *commandBufferB;
+ const vk::VkSemaphore semaphore = *semaphoreB;
+ const vk::VkPipelineStageFlags dstStage = readSync.stageMask;
+ const vk::VkSubmitInfo submitInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
+ DE_NULL,
+
+ 1u,
+ &semaphore,
+ &dstStage,
+
+ 1u,
+ &commandBuffer,
+ 0u,
+ DE_NULL,
+ };
+
+ VK_CHECK(m_vkdB.queueSubmit(queueB, 1u, &submitInfo, DE_NULL));
+ }
+
+ VK_CHECK(m_vkdA.queueWaitIdle(queueA));
+ VK_CHECK(m_vkdB.queueWaitIdle(queueB));
+
+ {
+ const Data expected = writeOp->getData();
+ const Data actual = readOp->getData();
+
+ DE_ASSERT(expected.size == actual.size);
+
+ if (0 != deMemCmp(expected.data, actual.data, expected.size))
+ {
+ const size_t maxBytesLogged = 256;
+ std::ostringstream expectedData;
+ std::ostringstream actualData;
+ size_t byteNdx = 0;
+
+ // Find first byte difference
+ for (; actual.data[byteNdx] == expected.data[byteNdx]; byteNdx++)
+ {
+ // Nothing
+ }
+
+ log << TestLog::Message << "First different byte at offset: " << byteNdx << TestLog::EndMessage;
+
+ // Log 8 previous bytes before the first incorrect byte
+ if (byteNdx > 8)
+ {
+ expectedData << "... ";
+ actualData << "... ";
+
+ byteNdx -= 8;
+ }
+ else
+ byteNdx = 0;
+
+ for (size_t i = 0; i < maxBytesLogged && byteNdx < expected.size; i++, byteNdx++)
+ {
+ expectedData << (i > 0 ? ", " : "") << (deUint32)expected.data[byteNdx];
+ actualData << (i > 0 ? ", " : "") << (deUint32)actual.data[byteNdx];
+ }
+
+ if (expected.size > byteNdx)
+ {
+ expectedData << "...";
+ actualData << "...";
+ }
+
+ log << TestLog::Message << "Expected data: (" << expectedData.str() << ")" << TestLog::EndMessage;
+ log << TestLog::Message << "Actual data: (" << actualData.str() << ")" << TestLog::EndMessage;
+
+ m_resultCollector.fail("Memory contents don't match");
+ }
+ }
+ }
+ catch (const tcu::NotSupportedError& error)
+ {
+ log << TestLog::Message << "Not supported: " << error.getMessage() << TestLog::EndMessage;
+ }
+ catch (const tcu::TestError& error)
+ {
+ m_resultCollector.fail(std::string("Exception: ") + error.getMessage());
+ }
+
+ // Move to next queue
+ {
+ m_queueBNdx++;
+
+ if (m_queueBNdx >= m_queueFamiliesB.size())
+ {
+ m_queueANdx++;
+
+ if (m_queueANdx >= m_queueFamiliesA.size())
+ {
+ return tcu::TestStatus(m_resultCollector.getResult(), m_resultCollector.getMessage());
+ }
+ else
+ {
+ m_queueBNdx = 0;
+
+ return tcu::TestStatus::incomplete();
+ }
+ }
+ else
+ return tcu::TestStatus::incomplete();
+ }
+}
+
+struct Progs
+{
+ void init (vk::SourceCollections& dst, TestConfig config) const
+ {
+ const de::UniquePtr<OperationSupport> readOp (makeOperationSupport(config.readOp, config.resource));
+ const de::UniquePtr<OperationSupport> writeOp (makeOperationSupport(config.writeOp, config.resource));
+
+ readOp->initPrograms(dst);
+ writeOp->initPrograms(dst);
+ }
+};
+
+} // anonymous
+
+tcu::TestCaseGroup* createCrossInstanceSharingTest (tcu::TestContext& testCtx)
+{
+ const struct
+ {
+ vk::VkExternalMemoryHandleTypeFlagBitsKHX memoryType;
+ vk::VkExternalSemaphoreHandleTypeFlagBitsKHX semaphoreType;
+ const char* nameSuffix;
+ } cases[] =
+ {
+ {
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX,
+ "_fd"
+ },
+ {
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX,
+ "_fence_fd"
+ },
+ {
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX,
+ "_win32"
+ },
+ };
+ de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "cross_instance", ""));
+
+ for (size_t writeOpNdx = 0; writeOpNdx < DE_LENGTH_OF_ARRAY(s_writeOps); ++writeOpNdx)
+ for (size_t readOpNdx = 0; readOpNdx < DE_LENGTH_OF_ARRAY(s_readOps); ++readOpNdx)
+ {
+ const OperationName writeOp = s_writeOps[writeOpNdx];
+ const OperationName readOp = s_readOps[readOpNdx];
+ const std::string opGroupName = getOperationName(writeOp) + "_" + getOperationName(readOp);
+ bool empty = true;
+
+ de::MovePtr<tcu::TestCaseGroup> opGroup (new tcu::TestCaseGroup(testCtx, opGroupName.c_str(), ""));
+
+ for (size_t resourceNdx = 0; resourceNdx < DE_LENGTH_OF_ARRAY(s_resources); ++resourceNdx)
+ {
+ const ResourceDescription& resource = s_resources[resourceNdx];
+
+ for (size_t caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
+ {
+ std::string name= getResourceName(resource) + cases[caseNdx].nameSuffix;
+
+ if (isResourceSupported(writeOp, resource) && isResourceSupported(readOp, resource))
+ {
+ const TestConfig config (resource, writeOp, readOp, cases[caseNdx].memoryType, cases[caseNdx].semaphoreType);
+
+ opGroup->addChild(new InstanceFactory1<SharingTestInstance, TestConfig, Progs>(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, "", Progs(), config));
+ empty = false;
+ }
+ }
+ }
+
+ if (!empty)
+ group->addChild(opGroup.release());
+ }
+
+ return group.release();
+}
+
+} // synchronization
+} // vkt
VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
VK_ERROR_INVALID_SHADER_NV = -1000012000,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
++ VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003,
VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
VK_RESULT_END_RANGE = VK_INCOMPLETE,
VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
- VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
- VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
- VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
- VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
- VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
- VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
- VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
+ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
- VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
- VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
- VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
- VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
- VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
- VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
- VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
- VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
- VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000,
+ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002,
+ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004,
+ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000,
+ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001,
+ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002,
+ VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000,
+ VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001,
++ VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002,
+ VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000,
- VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000,
++ VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000,
+ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001,
+ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000,
+ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000,
+ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001,
+ VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002,
+ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
- VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
- VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
- VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
- VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
- VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
- VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
+ VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
+ VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
++ VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageCreateFlagBits;
typedef enum VkMemoryHeapFlagBits {
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
++ VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryHeapFlagBits;
typedef VkFlags VkMemoryHeapFlags;
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
++ VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPipelineCreateFlagBits;
typedef VkFlags VkPipelineCreateFlags;
typedef enum VkDependencyFlagBits {
VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+ VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
++ VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDependencyFlagBits;
typedef VkFlags VkDependencyFlags;
#define VK_KHR_SWAPCHAIN_SPEC_VERSION 68
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+
+ typedef enum VkSwapchainCreateFlagBitsKHR {
++ VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
+ VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+ } VkSwapchainCreateFlagBitsKHR;
typedef VkFlags VkSwapchainCreateFlagsKHR;
typedef struct VkSwapchainCreateInfoKHR {
VkCommandPoolTrimFlagsKHR flags);
#endif
- const void* pNext;
- VkBool32 storageUniformBufferBlock16;
- VkBool32 storageUniform16;
+ #define VK_KHR_push_descriptor 1
+ #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
+ #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
+
+ typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t maxPushDescriptors;
+ } VkPhysicalDevicePushDescriptorPropertiesKHR;
+
+
+ typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
+
+ #ifndef VK_NO_PROTOTYPES
+ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites);
+ #endif
+
+#define VK_KHR_16bit_storage 1
+#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
+#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
+
+typedef struct VkPhysicalDevice16BitStorageFeaturesKHR {
+ VkStructureType sType;
++ void* pNext;
++ VkBool32 storageBuffer16BitAccess;
++ VkBool32 uniformAndStorageBuffer16BitAccess;
+ VkBool32 storagePushConstant16;
+ VkBool32 storageInputOutput16;
+} VkPhysicalDevice16BitStorageFeaturesKHR;
+
++
++
#define VK_KHR_incremental_present 1
#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
const char* pMessage);
#endif
- #define VK_NV_glsl_shader 1
- #define VK_NV_GLSL_SHADER_SPEC_VERSION 1
- #define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader"
-
-
- #define VK_IMG_filter_cubic 1
- #define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1
- #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
-
-
- #define VK_AMD_rasterization_order 1
- #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
- #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
-
-
- typedef enum VkRasterizationOrderAMD {
- VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
- VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
- VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
- VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
- VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
- VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
- } VkRasterizationOrderAMD;
-
- typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
- VkStructureType sType;
- const void* pNext;
- VkRasterizationOrderAMD rasterizationOrder;
- } VkPipelineRasterizationStateRasterizationOrderAMD;
-
-
-
- #define VK_AMD_shader_trinary_minmax 1
- #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
- #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
-
-
- #define VK_AMD_shader_explicit_vertex_parameter 1
- #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
- #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
-
-
- #define VK_EXT_debug_marker 1
- #define VK_EXT_DEBUG_MARKER_SPEC_VERSION 3
- #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
-
- typedef struct VkDebugMarkerObjectNameInfoEXT {
- VkStructureType sType;
- const void* pNext;
- VkDebugReportObjectTypeEXT objectType;
- uint64_t object;
- const char* pObjectName;
- } VkDebugMarkerObjectNameInfoEXT;
-
- typedef struct VkDebugMarkerObjectTagInfoEXT {
- VkStructureType sType;
- const void* pNext;
- VkDebugReportObjectTypeEXT objectType;
- uint64_t object;
- uint64_t tagName;
- size_t tagSize;
- const void* pTag;
- } VkDebugMarkerObjectTagInfoEXT;
-
- typedef struct VkDebugMarkerMarkerInfoEXT {
- VkStructureType sType;
- const void* pNext;
- const char* pMarkerName;
- float color[4];
- } VkDebugMarkerMarkerInfoEXT;
-
-
- typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo);
- typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo);
- typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
- typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
- typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
- VkDevice device,
- VkDebugMarkerObjectTagInfoEXT* pTagInfo);
-
- VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
- VkDevice device,
- VkDebugMarkerObjectNameInfoEXT* pNameInfo);
-
- VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
- VkCommandBuffer commandBuffer,
- VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
-
- VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer);
-
- VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
- VkCommandBuffer commandBuffer,
- VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
- #endif
-
- #define VK_AMD_gcn_shader 1
- #define VK_AMD_GCN_SHADER_SPEC_VERSION 1
- #define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader"
-
-
- #define VK_NV_dedicated_allocation 1
- #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
- #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
-
- typedef struct VkDedicatedAllocationImageCreateInfoNV {
- VkStructureType sType;
- const void* pNext;
- VkBool32 dedicatedAllocation;
- } VkDedicatedAllocationImageCreateInfoNV;
-
- typedef struct VkDedicatedAllocationBufferCreateInfoNV {
- VkStructureType sType;
- const void* pNext;
- VkBool32 dedicatedAllocation;
- } VkDedicatedAllocationBufferCreateInfoNV;
-
- typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
- VkStructureType sType;
- const void* pNext;
- VkImage image;
- VkBuffer buffer;
- } VkDedicatedAllocationMemoryAllocateInfoNV;
-
-
-
- #define VK_AMD_draw_indirect_count 1
- #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
- #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
-
- typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
- typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride);
-
- VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride);
- #endif
-
- #define VK_AMD_negative_viewport_height 1
- #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
- #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
-
-
- #define VK_AMD_gpu_shader_half_float 1
- #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
- #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
-
-
- #define VK_AMD_shader_ballot 1
- #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
- #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
-
+
+#define VK_KHX_multiview 1
+#define VK_KHX_MULTIVIEW_SPEC_VERSION 1
+#define VK_KHX_MULTIVIEW_EXTENSION_NAME "VK_KHX_multiview"
+
+typedef struct VkRenderPassMultiviewCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t subpassCount;
+ const uint32_t* pViewMasks;
+ uint32_t dependencyCount;
+ const int32_t* pViewOffsets;
+ uint32_t correlationMaskCount;
+ const uint32_t* pCorrelationMasks;
+} VkRenderPassMultiviewCreateInfoKHX;
+
+typedef struct VkPhysicalDeviceMultiviewFeaturesKHX {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 multiview;
+ VkBool32 multiviewGeometryShader;
+ VkBool32 multiviewTessellationShader;
+} VkPhysicalDeviceMultiviewFeaturesKHX;
+
+typedef struct VkPhysicalDeviceMultiviewPropertiesKHX {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t maxMultiviewViewCount;
+ uint32_t maxMultiviewInstanceIndex;
+} VkPhysicalDeviceMultiviewPropertiesKHX;
+
+
-
- #define VK_IMG_format_pvrtc 1
- #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1
- #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
-
-
- #define VK_NV_external_memory_capabilities 1
- #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
- #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
-
-
- typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
- VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
- } VkExternalMemoryHandleTypeFlagBitsNV;
- typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
-
- typedef enum VkExternalMemoryFeatureFlagBitsNV {
- VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
- VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
- VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
- VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
- } VkExternalMemoryFeatureFlagBitsNV;
- typedef VkFlags VkExternalMemoryFeatureFlagsNV;
-
- typedef struct VkExternalImageFormatPropertiesNV {
- VkImageFormatProperties imageFormatProperties;
- VkExternalMemoryFeatureFlagsNV externalMemoryFeatures;
- VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
- VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
- } VkExternalImageFormatPropertiesNV;
-
-
- typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
- VkExternalMemoryHandleTypeFlagsNV externalHandleType,
- VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
- #endif
-
- #define VK_NV_external_memory 1
- #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
- #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
-
- typedef struct VkExternalMemoryImageCreateInfoNV {
- VkStructureType sType;
- const void* pNext;
- VkExternalMemoryHandleTypeFlagsNV handleTypes;
- } VkExternalMemoryImageCreateInfoNV;
-
- typedef struct VkExportMemoryAllocateInfoNV {
- VkStructureType sType;
- const void* pNext;
- VkExternalMemoryHandleTypeFlagsNV handleTypes;
- } VkExportMemoryAllocateInfoNV;
-
-
-
- #ifdef VK_USE_PLATFORM_WIN32_KHR
- #define VK_NV_external_memory_win32 1
- #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
- #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
-
- typedef struct VkImportMemoryWin32HandleInfoNV {
- VkStructureType sType;
- const void* pNext;
- VkExternalMemoryHandleTypeFlagsNV handleType;
- HANDLE handle;
- } VkImportMemoryWin32HandleInfoNV;
-
- typedef struct VkExportMemoryWin32HandleInfoNV {
- VkStructureType sType;
- const void* pNext;
- const SECURITY_ATTRIBUTES* pAttributes;
- DWORD dwAccess;
- } VkExportMemoryWin32HandleInfoNV;
-
-
- typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
- VkDevice device,
- VkDeviceMemory memory,
- VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE* pHandle);
- #endif
- #endif /* VK_USE_PLATFORM_WIN32_KHR */
-
- #ifdef VK_USE_PLATFORM_WIN32_KHR
- #define VK_NV_win32_keyed_mutex 1
- #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
- #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
-
- typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
- VkStructureType sType;
- const void* pNext;
- uint32_t acquireCount;
- const VkDeviceMemory* pAcquireSyncs;
- const uint64_t* pAcquireKeys;
- const uint32_t* pAcquireTimeoutMilliseconds;
- uint32_t releaseCount;
- const VkDeviceMemory* pReleaseSyncs;
- const uint64_t* pReleaseKeys;
- } VkWin32KeyedMutexAcquireReleaseInfoNV;
-
-
- #endif /* VK_USE_PLATFORM_WIN32_KHR */
-
- #define VK_EXT_validation_flags 1
- #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
- #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
-
-
- typedef enum VkValidationCheckEXT {
- VK_VALIDATION_CHECK_ALL_EXT = 0,
- VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
- VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
- VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
- VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
- } VkValidationCheckEXT;
-
- typedef struct VkValidationFlagsEXT {
- VkStructureType sType;
- const void* pNext;
- uint32_t disabledValidationCheckCount;
- VkValidationCheckEXT* pDisabledValidationChecks;
- } VkValidationFlagsEXT;
-
-
-
+#define VK_KHX_external_memory_capabilities 1
+#define VK_LUID_SIZE_KHX 8
+#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_memory_capabilities"
+
+
+typedef enum VkExternalMemoryHandleTypeFlagBitsKHX {
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 0x00000008,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040,
+ VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
+} VkExternalMemoryHandleTypeFlagBitsKHX;
++typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX;
+
+typedef enum VkExternalMemoryFeatureFlagBitsKHX {
+ VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 0x00000004,
+ VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
+} VkExternalMemoryFeatureFlagBitsKHX;
-
- typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX;
+typedef VkFlags VkExternalMemoryFeatureFlagsKHX;
+
+typedef struct VkExternalMemoryPropertiesKHX {
+ VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures;
+ VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes;
+ VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes;
+} VkExternalMemoryPropertiesKHX;
+
+typedef struct VkPhysicalDeviceExternalImageFormatInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+} VkPhysicalDeviceExternalImageFormatInfoKHX;
+
+typedef struct VkExternalImageFormatPropertiesKHX {
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ VkExternalMemoryPropertiesKHX externalMemoryProperties;
+} VkExternalImageFormatPropertiesKHX;
+
+typedef struct VkPhysicalDeviceExternalBufferInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCreateFlags flags;
+ VkBufferUsageFlags usage;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+} VkPhysicalDeviceExternalBufferInfoKHX;
+
+typedef struct VkExternalBufferPropertiesKHX {
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ VkExternalMemoryPropertiesKHX externalMemoryProperties;
+} VkExternalBufferPropertiesKHX;
+
+typedef struct VkPhysicalDeviceIDPropertiesKHX {
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ uint8_t deviceUUID[VK_UUID_SIZE];
+ uint8_t driverUUID[VK_UUID_SIZE];
+ uint8_t deviceLUID[VK_LUID_SIZE_KHX];
+ VkBool32 deviceLUIDValid;
+} VkPhysicalDeviceIDPropertiesKHX;
+
++
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHX(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo,
+ VkExternalBufferPropertiesKHX* pExternalBufferProperties);
+#endif
+
+#define VK_KHX_external_memory 1
+#define VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHX_external_memory"
+#define VK_QUEUE_FAMILY_EXTERNAL_KHX (~0U-1)
+
+typedef struct VkExternalMemoryImageCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes;
+} VkExternalMemoryImageCreateInfoKHX;
+
+typedef struct VkExternalMemoryBufferCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes;
+} VkExternalMemoryBufferCreateInfoKHX;
+
+typedef struct VkExportMemoryAllocateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagsKHX handleTypes;
+} VkExportMemoryAllocateInfoKHX;
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+#define VK_KHX_external_memory_win32 1
+#define VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHX_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+ HANDLE handle;
+} VkImportMemoryWin32HandleInfoKHX;
+
+typedef struct VkExportMemoryWin32HandleInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+} VkExportMemoryWin32HandleInfoKHX;
+
++typedef struct VkMemoryWin32HandlePropertiesKHX {
++ VkStructureType sType;
++ void* pNext;
++ uint32_t memoryTypeBits;
++} VkMemoryWin32HandlePropertiesKHX;
++
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle);
++typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHX(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType,
+ HANDLE* pHandle);
++
++VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHX(
++ VkDevice device,
++ VkExternalMemoryHandleTypeFlagBitsKHX handleType,
++ HANDLE handle,
++ VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties);
+#endif
+#endif /* VK_USE_PLATFORM_WIN32_KHX */
+
+#define VK_KHX_external_memory_fd 1
+#define VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHX_external_memory_fd"
+
+typedef struct VkImportMemoryFdInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType;
+ int fd;
+} VkImportMemoryFdInfoKHX;
+
++typedef struct VkMemoryFdPropertiesKHX {
++ VkStructureType sType;
++ void* pNext;
++ uint32_t memoryTypeBits;
++} VkMemoryFdPropertiesKHX;
++
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd);
++typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHX(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagBitsKHX handleType,
+ int* pFd);
++
++VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHX(
++ VkDevice device,
++ VkExternalMemoryHandleTypeFlagBitsKHX handleType,
++ int fd,
++ VkMemoryFdPropertiesKHX* pMemoryFdProperties);
+#endif
+
- #ifdef VK_USE_PLATFORM_WIN32_KHX
++#ifdef VK_USE_PLATFORM_WIN32_KHR
+#define VK_KHX_win32_keyed_mutex 1
+#define VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHX_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t acquireCount;
+ const VkDeviceMemory* pAcquireSyncs;
+ const uint64_t* pAcquireKeys;
+ const uint32_t* pAcquireTimeouts;
+ uint32_t releaseCount;
+ const VkDeviceMemory* pReleaseSyncs;
+ const uint64_t* pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoKHX;
+
+
- #endif /* VK_USE_PLATFORM_WIN32_KHX */
++#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#define VK_KHX_external_semaphore_capabilities 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_semaphore_capabilities"
+
+
+typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHX {
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010,
+ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
+} VkExternalSemaphoreHandleTypeFlagBitsKHX;
++typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX;
+
+typedef enum VkExternalSemaphoreFeatureFlagBitsKHX {
+ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 0x00000001,
+ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 0x00000002,
+ VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
+} VkExternalSemaphoreFeatureFlagBitsKHX;
-
- typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX;
+typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX;
+
+typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType;
+} VkPhysicalDeviceExternalSemaphoreInfoKHX;
+
+typedef struct VkExternalSemaphorePropertiesKHX {
+ VkStructureType sType;
- const void* pNext;
++ void* pNext;
+ VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes;
+ VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes;
+ VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures;
+} VkExternalSemaphorePropertiesKHX;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo,
+ VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties);
+#endif
+
+#define VK_KHX_external_semaphore 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHX_external_semaphore"
+
+typedef struct VkExportSemaphoreCreateInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkExternalSemaphoreHandleTypeFlagsKHX handleTypes;
+} VkExportSemaphoreCreateInfoKHX;
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHX
+#define VK_KHX_external_semaphore_win32 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHX_external_semaphore_win32"
+
+typedef struct VkImportSemaphoreWin32HandleInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagsKHX handleType;
+ HANDLE handle;
+} VkImportSemaphoreWin32HandleInfoKHX;
+
+typedef struct VkExportSemaphoreWin32HandleInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+} VkExportSemaphoreWin32HandleInfoKHX;
+
+typedef struct VkD3D12FenceSubmitInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreValuesCount;
+ const uint64_t* pWaitSemaphoreValues;
+ uint32_t signalSemaphoreValuesCount;
+ const uint64_t* pSignalSemaphoreValues;
+} VkD3D12FenceSubmitInfoKHX;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHX)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHX(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHX(
+ VkDevice device,
+ VkSemaphore semaphore,
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType,
+ HANDLE* pHandle);
+#endif
+#endif /* VK_USE_PLATFORM_WIN32_KHX */
+
+#define VK_KHX_external_semaphore_fd 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
+#define VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHX_external_semaphore_fd"
+
+typedef struct VkImportSemaphoreFdInfoKHX {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType;
+ int fd;
+} VkImportSemaphoreFdInfoKHX;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHX)(VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHX(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHX(
+ VkDevice device,
+ VkSemaphore semaphore,
+ VkExternalSemaphoreHandleTypeFlagBitsKHX handleType,
+ int* pFd);
+#endif
+
- #define VK_NVX_device_generated_commands 1
- VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
- VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
-
- #define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1
- #define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
-
-
- typedef enum VkIndirectCommandsTokenTypeNVX {
- VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0,
- VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1,
- VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2,
- VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3,
- VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4,
- VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5,
- VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6,
- VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7,
- VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX,
- VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX,
- VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX + 1),
- VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
- } VkIndirectCommandsTokenTypeNVX;
-
- typedef enum VkObjectEntryTypeNVX {
- VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0,
- VK_OBJECT_ENTRY_PIPELINE_NVX = 1,
- VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2,
- VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3,
- VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4,
- VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX,
- VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX,
- VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX + 1),
- VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
- } VkObjectEntryTypeNVX;
-
-
- typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
- VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
- } VkIndirectCommandsLayoutUsageFlagBitsNVX;
- typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
-
- typedef enum VkObjectEntryUsageFlagBitsNVX {
- VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
- VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
- VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
- } VkObjectEntryUsageFlagBitsNVX;
- typedef VkFlags VkObjectEntryUsageFlagsNVX;
-
- typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
- VkStructureType sType;
- const void* pNext;
- VkBool32 computeBindingPointSupport;
- } VkDeviceGeneratedCommandsFeaturesNVX;
-
- typedef struct VkDeviceGeneratedCommandsLimitsNVX {
- VkStructureType sType;
- const void* pNext;
- uint32_t maxIndirectCommandsLayoutTokenCount;
- uint32_t maxObjectEntryCounts;
- uint32_t minSequenceCountBufferOffsetAlignment;
- uint32_t minSequenceIndexBufferOffsetAlignment;
- uint32_t minCommandsTokenBufferOffsetAlignment;
- } VkDeviceGeneratedCommandsLimitsNVX;
-
- typedef struct VkIndirectCommandsTokenNVX {
- VkIndirectCommandsTokenTypeNVX tokenType;
- VkBuffer buffer;
- VkDeviceSize offset;
- } VkIndirectCommandsTokenNVX;
-
- typedef struct VkIndirectCommandsLayoutTokenNVX {
- VkIndirectCommandsTokenTypeNVX tokenType;
- uint32_t bindingUnit;
- uint32_t dynamicCount;
- uint32_t divisor;
- } VkIndirectCommandsLayoutTokenNVX;
-
- typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
- VkStructureType sType;
- const void* pNext;
- VkPipelineBindPoint pipelineBindPoint;
- VkIndirectCommandsLayoutUsageFlagsNVX flags;
- uint32_t tokenCount;
- const VkIndirectCommandsLayoutTokenNVX* pTokens;
- } VkIndirectCommandsLayoutCreateInfoNVX;
-
- typedef struct VkCmdProcessCommandsInfoNVX {
- VkStructureType sType;
- const void* pNext;
- VkObjectTableNVX objectTable;
- VkIndirectCommandsLayoutNVX indirectCommandsLayout;
- uint32_t indirectCommandsTokenCount;
- const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens;
- uint32_t maxSequencesCount;
- VkCommandBuffer targetCommandBuffer;
- VkBuffer sequencesCountBuffer;
- VkDeviceSize sequencesCountOffset;
- VkBuffer sequencesIndexBuffer;
- VkDeviceSize sequencesIndexOffset;
- } VkCmdProcessCommandsInfoNVX;
-
- typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
- VkStructureType sType;
- const void* pNext;
- VkObjectTableNVX objectTable;
- VkIndirectCommandsLayoutNVX indirectCommandsLayout;
- uint32_t maxSequencesCount;
- } VkCmdReserveSpaceForCommandsInfoNVX;
-
- typedef struct VkObjectTableCreateInfoNVX {
- VkStructureType sType;
- const void* pNext;
- uint32_t objectCount;
- const VkObjectEntryTypeNVX* pObjectEntryTypes;
- const uint32_t* pObjectEntryCounts;
- const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
- uint32_t maxUniformBuffersPerDescriptor;
- uint32_t maxStorageBuffersPerDescriptor;
- uint32_t maxStorageImagesPerDescriptor;
- uint32_t maxSampledImagesPerDescriptor;
- uint32_t maxPipelineLayouts;
- } VkObjectTableCreateInfoNVX;
-
- typedef struct VkObjectTableEntryNVX {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- } VkObjectTableEntryNVX;
-
- typedef struct VkObjectTablePipelineEntryNVX {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkPipeline pipeline;
- } VkObjectTablePipelineEntryNVX;
-
- typedef struct VkObjectTableDescriptorSetEntryNVX {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkPipelineLayout pipelineLayout;
- VkDescriptorSet descriptorSet;
- } VkObjectTableDescriptorSetEntryNVX;
-
- typedef struct VkObjectTableVertexBufferEntryNVX {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkBuffer buffer;
- } VkObjectTableVertexBufferEntryNVX;
-
- typedef struct VkObjectTableIndexBufferEntryNVX {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkBuffer buffer;
- } VkObjectTableIndexBufferEntryNVX;
-
- typedef struct VkObjectTablePushConstantEntryNVX {
- VkObjectEntryTypeNVX type;
- VkObjectEntryUsageFlagsNVX flags;
- VkPipelineLayout pipelineLayout;
- VkShaderStageFlags stageFlags;
- } VkObjectTablePushConstantEntryNVX;
-
-
- typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
- typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
- typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
- typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
- typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
- typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
- typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices);
- typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
- typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
- VkCommandBuffer commandBuffer,
- const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
-
- VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
- VkCommandBuffer commandBuffer,
- const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
-
- VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
- VkDevice device,
- const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
-
- VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
- VkDevice device,
- VkIndirectCommandsLayoutNVX indirectCommandsLayout,
- const VkAllocationCallbacks* pAllocator);
-
- VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
- VkDevice device,
- const VkObjectTableCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkObjectTableNVX* pObjectTable);
-
- VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
- VkDevice device,
- VkObjectTableNVX objectTable,
- const VkAllocationCallbacks* pAllocator);
-
- VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
- VkDevice device,
- VkObjectTableNVX objectTable,
- uint32_t objectCount,
- const VkObjectTableEntryNVX* const* ppObjectTableEntries,
- const uint32_t* pObjectIndices);
-
- VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
- VkDevice device,
- VkObjectTableNVX objectTable,
- uint32_t objectCount,
- const VkObjectEntryTypeNVX* pObjectEntryTypes,
- const uint32_t* pObjectIndices);
-
- VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
- VkPhysicalDevice physicalDevice,
- VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
- VkDeviceGeneratedCommandsLimitsNVX* pLimits);
- #endif
-
- #define VK_KHR_push_descriptor 1
- #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
- #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
-
- typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
- VkStructureType sType;
- void* pNext;
- uint32_t maxPushDescriptors;
- } VkPhysicalDevicePushDescriptorPropertiesKHR;
-
-
- typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites);
- #endif
-
- #define VK_KHR_descriptor_update_template 1
- VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
-
- #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
- #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
-
-
- typedef enum VkDescriptorUpdateTemplateTypeKHR {
- VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
- VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
- VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
- VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
- VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1),
- VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
- } VkDescriptorUpdateTemplateTypeKHR;
-
- typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
-
- typedef struct VkDescriptorUpdateTemplateEntryKHR {
- uint32_t dstBinding;
- uint32_t dstArrayElement;
- uint32_t descriptorCount;
- VkDescriptorType descriptorType;
- size_t offset;
- size_t stride;
- } VkDescriptorUpdateTemplateEntryKHR;
-
- typedef struct VkDescriptorUpdateTemplateCreateInfoKHR {
- VkStructureType sType;
- void* pNext;
- VkDescriptorUpdateTemplateCreateFlagsKHR flags;
- uint32_t descriptorUpdateEntryCount;
- const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
- VkDescriptorUpdateTemplateTypeKHR templateType;
- VkDescriptorSetLayout descriptorSetLayout;
- VkPipelineBindPoint pipelineBindPoint;
- VkPipelineLayout pipelineLayout;
- uint32_t set;
- } VkDescriptorUpdateTemplateCreateInfoKHR;
-
-
- typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
- typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
- typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
- typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
-
- #ifndef VK_NO_PROTOTYPES
- VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
-
- VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device,
- VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator);
-
- VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
- const void* pData);
-
- VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
- VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
- VkPipelineLayout layout,
- uint32_t set,
- const void* pData);
- #endif
-
#define VK_GOOGLE_display_timing 1
#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 2
#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
++
#ifdef __cplusplus
}
#endif
projects / platform / upstream / VK-GL-CTS.git / commitdiff