Skip to content

Instantly share code, notes, and snippets.

@technicallyagd

technicallyagd/vulkan.nim

Created November 1, 2018 10:05
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save technicallyagd/8db191dae52a3eb62ca68699ca858019 to your computer and use it in GitHub Desktop.
Save technicallyagd/8db191dae52a3eb62ca68699ca858019 to your computer and use it in GitHub Desktop.
Download ZIP
vulkan.nim for Version 1.1.85
Raw
vulkan.nim
template vkMakeVersion*(major, minor, patch: untyped): untyped =
(((major) shl 22) or ((minor) shl 12) or (patch))
const
vkVersion10* = vkMakeVersion(1, 0, 0)
template vkVersionMajor*(version: untyped): untyped =
((uint32)(version) shr 22)
template vkVersionMinor*(version: untyped): untyped =
(((uint32)(version) shr 12) and 0x000003FF)
template vkVersionPatch*(version: untyped): untyped =
((uint32)(version) and 0x00000FFF)
const
VK_HEADER_VERSION* = 85
VK_LOD_CLAMP_NONE* = 1000.0f
VK_REMAINING_MIP_LEVELS* = (not 0'u)
VK_REMAINING_ARRAY_LAYERS* = (not 0'u)
VK_WHOLE_SIZE* = (not 0'u64)
VK_ATTACHMENT_UNUSED* = (not 0'u)
VK_TRUE* = 1
VK_FALSE* = 0
const
vkNullHandle* = 0
const
VK_QUEUE_FAMILY_IGNORED* = (not 0'u)
VK_SUBPASS_EXTERNAL* = (not 0'u)
type
VkPipelineCacheHeaderVersion* {.size: sizeof(cint).} = enum
VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1
VkResult* {.size: sizeof(cint).} = enum
VK_ERROR_NOT_PERMITTED_EXT = -1000174001
VK_ERROR_FRAGMENTATION_EXT = -1000161000
VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003
VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000
VK_ERROR_INVALID_SHADER_NV = -1000012000
VK_ERROR_VALIDATION_FAILED_EXT = -1000011001
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001
VK_ERROR_OUT_OF_DATE_KHR = -1000001004
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001
VK_ERROR_SURFACE_LOST_KHR = -1000000000
VK_ERROR_FRAGMENTED_POOL = -12
VK_ERROR_FORMAT_NOT_SUPPORTED = -11
VK_ERROR_TOO_MANY_OBJECTS = -10
VK_ERROR_INCOMPATIBLE_DRIVER = -9
VK_ERROR_FEATURE_NOT_PRESENT = -8
VK_ERROR_EXTENSION_NOT_PRESENT = -7
VK_ERROR_LAYER_NOT_PRESENT = -6
VK_ERROR_MEMORY_MAP_FAILED = -5
VK_ERROR_DEVICE_LOST = -4
VK_ERROR_INITIALIZATION_FAILED = -3
VK_ERROR_OUT_OF_DEVICE_MEMORY = -2
VK_ERROR_OUT_OF_HOST_MEMORY = -1
VK_SUCCESS = 0
VK_NOT_READY = 1
VK_TIMEOUT = 2
VK_EVENT_SET = 3
VK_EVENT_RESET = 4
VK_INCOMPLETE = 5
VK_SUBOPTIMAL_KHR = 1000001003
VkStructureType* {.size: sizeof(cint).} = enum
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_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000
VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000
VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001
VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001
VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002
VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000
VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000
VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001
VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002
VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004
VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006
VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000
VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003
VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004
VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006
VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007
VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009
VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010
VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011
VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014
VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000
VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000
VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002
VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001
VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002
VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000
VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001
VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000
VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001
VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000
VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001
VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000
VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001
VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002
VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003
VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004
VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000
VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000
VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001
VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002
VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003
VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000
VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001
VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001
VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002
VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004
VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005
VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006
VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000
VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001
VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000
VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000
VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000
VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003
VK_STRUCTURE_TYPE_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_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000
VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000
VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001
VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002
VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003
VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001
VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000
VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001
VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000
VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003
VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000
VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001
VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003
VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004
VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002
VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003
VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000
VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001
VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003
VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004
VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002
VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000
VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001
VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002
VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001
VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000
VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005
VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX = 1000165000
VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX = 1000165001
VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX = 1000165002
VK_STRUCTURE_TYPE_GEOMETRY_NVX = 1000165003
VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX = 1000165004
VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX = 1000165005
VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX = 1000165006
VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX = 1000165007
VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX = 1000165008
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX = 1000165009
VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX = 1000165010
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000
VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001
VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000
VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002
VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000
VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000
VkFlags* = uint32
VkInstanceCreateFlags* = VkFlags
VkApplicationInfo* = object
sType: VkStructureType
pNext: pointer
pApplicationName: cstring
applicationVersion: uint32
pEngineName: cstring
engineVersion: uint32
apiVersion: uint32
VkInstanceCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkInstanceCreateFlags
pApplicationInfo: ptr VkApplicationInfo
enabledLayerCount: uint32
ppEnabledLayerNames: cstring
enabledExtensionCount: uint32
ppEnabledExtensionNames: cstring
VkSystemAllocationScope* {.size: sizeof(cint).} = enum
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1
VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4
PFN_vkAllocationFunction* = proc (
pUserData: pointer;
size: csize;
alignment: csize;
allocationScope: VkSystemAllocationScope;
): pointer {.cdecl.}
PFN_vkReallocationFunction* = proc (
pUserData: pointer;
pOriginal: pointer;
size: csize;
alignment: csize;
allocationScope: VkSystemAllocationScope;
): pointer {.cdecl.}
PFN_vkFreeFunction* = proc (
pUserData: pointer;
pMemory: pointer;
): void {.cdecl.}
VkInternalAllocationType* {.size: sizeof(cint).} = enum
VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
PFN_vkInternalAllocationNotification* = proc (
pUserData: pointer;
size: csize;
allocationType: VkInternalAllocationType;
allocationScope: VkSystemAllocationScope;
): void {.cdecl.}
PFN_vkInternalFreeNotification* = proc (
pUserData: pointer;
size: csize;
allocationType: VkInternalAllocationType;
allocationScope: VkSystemAllocationScope;
): void {.cdecl.}
VkAllocationCallbacks* = object
pUserData: pointer
pfnAllocation: PFN_vkAllocationFunction
pfnReallocation: PFN_vkReallocationFunction
pfnFree: PFN_vkFreeFunction
pfnInternalAllocation: PFN_vkInternalAllocationNotification
pfnInternalFree: PFN_vkInternalFreeNotification
VkHandle* = int64
VkNonDispatchableHandle* = int64
VkInstance* = VkHandle
PFN_vkCreateInstance* = proc (
pCreateInfo: ptr VkInstanceCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pInstance: ptr VkInstance;
): VkResult {.cdecl.}
PFN_vkDestroyInstance* = proc (
instance: VkInstance;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkPhysicalDevice* = VkHandle
PFN_vkEnumeratePhysicalDevices* = proc (
instance: VkInstance;
pPhysicalDeviceCount: ptr uint32;
pPhysicalDevices: ptr VkPhysicalDevice;
): VkResult {.cdecl.}
VkBool32* = uint32
VkPhysicalDeviceFeatures* = object
robustBufferAccess: VkBool32
fullDrawIndexUint32: VkBool32
imageCubeArray: VkBool32
independentBlend: VkBool32
geometryShader: VkBool32
tessellationShader: VkBool32
sampleRateShading: VkBool32
dualSrcBlend: VkBool32
logicOp: VkBool32
multiDrawIndirect: VkBool32
drawIndirectFirstInstance: VkBool32
depthClamp: VkBool32
depthBiasClamp: VkBool32
fillModeNonSolid: VkBool32
depthBounds: VkBool32
wideLines: VkBool32
largePoints: VkBool32
alphaToOne: VkBool32
multiViewport: VkBool32
samplerAnisotropy: VkBool32
textureCompressionETC2: VkBool32
textureCompressionASTC_LDR: VkBool32
textureCompressionBC: VkBool32
occlusionQueryPrecise: VkBool32
pipelineStatisticsQuery: VkBool32
vertexPipelineStoresAndAtomics: VkBool32
fragmentStoresAndAtomics: VkBool32
shaderTessellationAndGeometryPointSize: VkBool32
shaderImageGatherExtended: VkBool32
shaderStorageImageExtendedFormats: VkBool32
shaderStorageImageMultisample: VkBool32
shaderStorageImageReadWithoutFormat: VkBool32
shaderStorageImageWriteWithoutFormat: VkBool32
shaderUniformBufferArrayDynamicIndexing: VkBool32
shaderSampledImageArrayDynamicIndexing: VkBool32
shaderStorageBufferArrayDynamicIndexing: VkBool32
shaderStorageImageArrayDynamicIndexing: VkBool32
shaderClipDistance: VkBool32
shaderCullDistance: VkBool32
shaderFloat64: VkBool32
shaderInt64: VkBool32
shaderInt16: VkBool32
shaderResourceResidency: VkBool32
shaderResourceMinLod: VkBool32
sparseBinding: VkBool32
sparseResidencyBuffer: VkBool32
sparseResidencyImage2D: VkBool32
sparseResidencyImage3D: VkBool32
sparseResidency2Samples: VkBool32
sparseResidency4Samples: VkBool32
sparseResidency8Samples: VkBool32
sparseResidency16Samples: VkBool32
sparseResidencyAliased: VkBool32
variableMultisampleRate: VkBool32
inheritedQueries: VkBool32
PFN_vkGetPhysicalDeviceFeatures* = proc (
physicalDevice: VkPhysicalDevice;
pFeatures: ptr VkPhysicalDeviceFeatures;
): void {.cdecl.}
VkFormat* {.size: sizeof(cint).} = enum
VK_FORMAT_UNDEFINED = 0
VK_FORMAT_R4G4_UNORM_PACK8 = 1
VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2
VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3
VK_FORMAT_R5G6B5_UNORM_PACK16 = 4
VK_FORMAT_B5G6R5_UNORM_PACK16 = 5
VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6
VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7
VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8
VK_FORMAT_R8_UNORM = 9
VK_FORMAT_R8_SNORM = 10
VK_FORMAT_R8_USCALED = 11
VK_FORMAT_R8_SSCALED = 12
VK_FORMAT_R8_UINT = 13
VK_FORMAT_R8_SINT = 14
VK_FORMAT_R8_SRGB = 15
VK_FORMAT_R8G8_UNORM = 16
VK_FORMAT_R8G8_SNORM = 17
VK_FORMAT_R8G8_USCALED = 18
VK_FORMAT_R8G8_SSCALED = 19
VK_FORMAT_R8G8_UINT = 20
VK_FORMAT_R8G8_SINT = 21
VK_FORMAT_R8G8_SRGB = 22
VK_FORMAT_R8G8B8_UNORM = 23
VK_FORMAT_R8G8B8_SNORM = 24
VK_FORMAT_R8G8B8_USCALED = 25
VK_FORMAT_R8G8B8_SSCALED = 26
VK_FORMAT_R8G8B8_UINT = 27
VK_FORMAT_R8G8B8_SINT = 28
VK_FORMAT_R8G8B8_SRGB = 29
VK_FORMAT_B8G8R8_UNORM = 30
VK_FORMAT_B8G8R8_SNORM = 31
VK_FORMAT_B8G8R8_USCALED = 32
VK_FORMAT_B8G8R8_SSCALED = 33
VK_FORMAT_B8G8R8_UINT = 34
VK_FORMAT_B8G8R8_SINT = 35
VK_FORMAT_B8G8R8_SRGB = 36
VK_FORMAT_R8G8B8A8_UNORM = 37
VK_FORMAT_R8G8B8A8_SNORM = 38
VK_FORMAT_R8G8B8A8_USCALED = 39
VK_FORMAT_R8G8B8A8_SSCALED = 40
VK_FORMAT_R8G8B8A8_UINT = 41
VK_FORMAT_R8G8B8A8_SINT = 42
VK_FORMAT_R8G8B8A8_SRGB = 43
VK_FORMAT_B8G8R8A8_UNORM = 44
VK_FORMAT_B8G8R8A8_SNORM = 45
VK_FORMAT_B8G8R8A8_USCALED = 46
VK_FORMAT_B8G8R8A8_SSCALED = 47
VK_FORMAT_B8G8R8A8_UINT = 48
VK_FORMAT_B8G8R8A8_SINT = 49
VK_FORMAT_B8G8R8A8_SRGB = 50
VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51
VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52
VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53
VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54
VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55
VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56
VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57
VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58
VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59
VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60
VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61
VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62
VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63
VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64
VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65
VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66
VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67
VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68
VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69
VK_FORMAT_R16_UNORM = 70
VK_FORMAT_R16_SNORM = 71
VK_FORMAT_R16_USCALED = 72
VK_FORMAT_R16_SSCALED = 73
VK_FORMAT_R16_UINT = 74
VK_FORMAT_R16_SINT = 75
VK_FORMAT_R16_SFLOAT = 76
VK_FORMAT_R16G16_UNORM = 77
VK_FORMAT_R16G16_SNORM = 78
VK_FORMAT_R16G16_USCALED = 79
VK_FORMAT_R16G16_SSCALED = 80
VK_FORMAT_R16G16_UINT = 81
VK_FORMAT_R16G16_SINT = 82
VK_FORMAT_R16G16_SFLOAT = 83
VK_FORMAT_R16G16B16_UNORM = 84
VK_FORMAT_R16G16B16_SNORM = 85
VK_FORMAT_R16G16B16_USCALED = 86
VK_FORMAT_R16G16B16_SSCALED = 87
VK_FORMAT_R16G16B16_UINT = 88
VK_FORMAT_R16G16B16_SINT = 89
VK_FORMAT_R16G16B16_SFLOAT = 90
VK_FORMAT_R16G16B16A16_UNORM = 91
VK_FORMAT_R16G16B16A16_SNORM = 92
VK_FORMAT_R16G16B16A16_USCALED = 93
VK_FORMAT_R16G16B16A16_SSCALED = 94
VK_FORMAT_R16G16B16A16_UINT = 95
VK_FORMAT_R16G16B16A16_SINT = 96
VK_FORMAT_R16G16B16A16_SFLOAT = 97
VK_FORMAT_R32_UINT = 98
VK_FORMAT_R32_SINT = 99
VK_FORMAT_R32_SFLOAT = 100
VK_FORMAT_R32G32_UINT = 101
VK_FORMAT_R32G32_SINT = 102
VK_FORMAT_R32G32_SFLOAT = 103
VK_FORMAT_R32G32B32_UINT = 104
VK_FORMAT_R32G32B32_SINT = 105
VK_FORMAT_R32G32B32_SFLOAT = 106
VK_FORMAT_R32G32B32A32_UINT = 107
VK_FORMAT_R32G32B32A32_SINT = 108
VK_FORMAT_R32G32B32A32_SFLOAT = 109
VK_FORMAT_R64_UINT = 110
VK_FORMAT_R64_SINT = 111
VK_FORMAT_R64_SFLOAT = 112
VK_FORMAT_R64G64_UINT = 113
VK_FORMAT_R64G64_SINT = 114
VK_FORMAT_R64G64_SFLOAT = 115
VK_FORMAT_R64G64B64_UINT = 116
VK_FORMAT_R64G64B64_SINT = 117
VK_FORMAT_R64G64B64_SFLOAT = 118
VK_FORMAT_R64G64B64A64_UINT = 119
VK_FORMAT_R64G64B64A64_SINT = 120
VK_FORMAT_R64G64B64A64_SFLOAT = 121
VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122
VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123
VK_FORMAT_D16_UNORM = 124
VK_FORMAT_X8_D24_UNORM_PACK32 = 125
VK_FORMAT_D32_SFLOAT = 126
VK_FORMAT_S8_UINT = 127
VK_FORMAT_D16_UNORM_S8_UINT = 128
VK_FORMAT_D24_UNORM_S8_UINT = 129
VK_FORMAT_D32_SFLOAT_S8_UINT = 130
VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131
VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132
VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133
VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134
VK_FORMAT_BC2_UNORM_BLOCK = 135
VK_FORMAT_BC2_SRGB_BLOCK = 136
VK_FORMAT_BC3_UNORM_BLOCK = 137
VK_FORMAT_BC3_SRGB_BLOCK = 138
VK_FORMAT_BC4_UNORM_BLOCK = 139
VK_FORMAT_BC4_SNORM_BLOCK = 140
VK_FORMAT_BC5_UNORM_BLOCK = 141
VK_FORMAT_BC5_SNORM_BLOCK = 142
VK_FORMAT_BC6H_UFLOAT_BLOCK = 143
VK_FORMAT_BC6H_SFLOAT_BLOCK = 144
VK_FORMAT_BC7_UNORM_BLOCK = 145
VK_FORMAT_BC7_SRGB_BLOCK = 146
VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152
VK_FORMAT_EAC_R11_UNORM_BLOCK = 153
VK_FORMAT_EAC_R11_SNORM_BLOCK = 154
VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155
VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156
VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157
VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158
VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159
VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160
VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161
VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162
VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163
VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164
VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165
VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166
VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167
VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168
VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169
VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170
VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171
VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172
VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173
VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174
VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175
VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176
VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177
VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178
VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179
VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180
VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181
VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182
VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183
VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184
VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000
VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001
VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002
VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003
VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004
VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007
VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000
VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001
VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002
VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003
VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004
VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005
VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006
VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007
VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008
VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009
VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010
VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016
VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017
VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018
VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019
VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020
VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026
VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027
VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028
VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029
VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030
VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031
VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032
VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033
VkFormatFeatureFlags* = VkFlags
VkFormatProperties* = object
linearTilingFeatures: VkFormatFeatureFlags
optimalTilingFeatures: VkFormatFeatureFlags
bufferFeatures: VkFormatFeatureFlags
PFN_vkGetPhysicalDeviceFormatProperties* = proc (
physicalDevice: VkPhysicalDevice;
format: VkFormat;
pFormatProperties: ptr VkFormatProperties;
): void {.cdecl.}
VkImageType* {.size: sizeof(cint).} = enum
VK_IMAGE_TYPE_1D = 0
VK_IMAGE_TYPE_2D = 1
VK_IMAGE_TYPE_3D = 2
VkImageTiling* {.size: sizeof(cint).} = enum
VK_IMAGE_TILING_OPTIMAL = 0
VK_IMAGE_TILING_LINEAR = 1
VkImageUsageFlags* = VkFlags
VkImageCreateFlags* = VkFlags
VkExtent3D* = object
width: uint32
height: uint32
depth: uint32
VkSampleCountFlags* = VkFlags
VkDeviceSize* = uint64
VkImageFormatProperties* = object
maxExtent: VkExtent3D
maxMipLevels: uint32
maxArrayLayers: uint32
sampleCounts: VkSampleCountFlags
maxResourceSize: VkDeviceSize
PFN_vkGetPhysicalDeviceImageFormatProperties* = proc (
physicalDevice: VkPhysicalDevice;
format: VkFormat;
theType: VkImageType;
tiling: VkImageTiling;
usage: VkImageUsageFlags;
flags: VkImageCreateFlags;
pImageFormatProperties: ptr VkImageFormatProperties;
): VkResult {.cdecl.}
VkPhysicalDeviceType* {.size: sizeof(cint).} = enum
VK_PHYSICAL_DEVICE_TYPE_OTHER = 0
VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1
VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2
VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3
VK_PHYSICAL_DEVICE_TYPE_CPU = 4
const
VK_MAX_PHYSICAL_DEVICE_NAME_SIZE* = 256
VK_UUID_SIZE* = 16
type
VkPhysicalDeviceLimits* = object
maxImageDimension1D: uint32
maxImageDimension2D: uint32
maxImageDimension3D: uint32
maxImageDimensionCube: uint32
maxImageArrayLayers: uint32
maxTexelBufferElements: uint32
maxUniformBufferRange: uint32
maxStorageBufferRange: uint32
maxPushConstantsSize: uint32
maxMemoryAllocationCount: uint32
maxSamplerAllocationCount: uint32
bufferImageGranularity: VkDeviceSize
sparseAddressSpaceSize: VkDeviceSize
maxBoundDescriptorSets: uint32
maxPerStageDescriptorSamplers: uint32
maxPerStageDescriptorUniformBuffers: uint32
maxPerStageDescriptorStorageBuffers: uint32
maxPerStageDescriptorSampledImages: uint32
maxPerStageDescriptorStorageImages: uint32
maxPerStageDescriptorInputAttachments: uint32
maxPerStageResources: uint32
maxDescriptorSetSamplers: uint32
maxDescriptorSetUniformBuffers: uint32
maxDescriptorSetUniformBuffersDynamic: uint32
maxDescriptorSetStorageBuffers: uint32
maxDescriptorSetStorageBuffersDynamic: uint32
maxDescriptorSetSampledImages: uint32
maxDescriptorSetStorageImages: uint32
maxDescriptorSetInputAttachments: uint32
maxVertexInputAttributes: uint32
maxVertexInputBindings: uint32
maxVertexInputAttributeOffset: uint32
maxVertexInputBindingStride: uint32
maxVertexOutputComponents: uint32
maxTessellationGenerationLevel: uint32
maxTessellationPatchSize: uint32
maxTessellationControlPerVertexInputComponents: uint32
maxTessellationControlPerVertexOutputComponents: uint32
maxTessellationControlPerPatchOutputComponents: uint32
maxTessellationControlTotalOutputComponents: uint32
maxTessellationEvaluationInputComponents: uint32
maxTessellationEvaluationOutputComponents: uint32
maxGeometryShaderInvocations: uint32
maxGeometryInputComponents: uint32
maxGeometryOutputComponents: uint32
maxGeometryOutputVertices: uint32
maxGeometryTotalOutputComponents: uint32
maxFragmentInputComponents: uint32
maxFragmentOutputAttachments: uint32
maxFragmentDualSrcAttachments: uint32
maxFragmentCombinedOutputResources: uint32
maxComputeSharedMemorySize: uint32
maxComputeWorkGroupCount: array[3, uint32]
maxComputeWorkGroupInvocations: uint32
maxComputeWorkGroupSize: array[3, uint32]
subPixelPrecisionBits: uint32
subTexelPrecisionBits: uint32
mipmapPrecisionBits: uint32
maxDrawIndexedIndexValue: uint32
maxDrawIndirectCount: uint32
maxSamplerLodBias: cfloat
maxSamplerAnisotropy: cfloat
maxViewports: uint32
maxViewportDimensions: array[2, uint32]
viewportBoundsRange: array[2, cfloat]
viewportSubPixelBits: uint32
minMemoryMapAlignment: csize
minTexelBufferOffsetAlignment: VkDeviceSize
minUniformBufferOffsetAlignment: VkDeviceSize
minStorageBufferOffsetAlignment: VkDeviceSize
minTexelOffset: int32
maxTexelOffset: uint32
minTexelGatherOffset: int32
maxTexelGatherOffset: uint32
minInterpolationOffset: cfloat
maxInterpolationOffset: cfloat
subPixelInterpolationOffsetBits: uint32
maxFramebufferWidth: uint32
maxFramebufferHeight: uint32
maxFramebufferLayers: uint32
framebufferColorSampleCounts: VkSampleCountFlags
framebufferDepthSampleCounts: VkSampleCountFlags
framebufferStencilSampleCounts: VkSampleCountFlags
framebufferNoAttachmentsSampleCounts: VkSampleCountFlags
maxColorAttachments: uint32
sampledImageColorSampleCounts: VkSampleCountFlags
sampledImageIntegerSampleCounts: VkSampleCountFlags
sampledImageDepthSampleCounts: VkSampleCountFlags
sampledImageStencilSampleCounts: VkSampleCountFlags
storageImageSampleCounts: VkSampleCountFlags
maxSampleMaskWords: uint32
timestampComputeAndGraphics: VkBool32
timestampPeriod: cfloat
maxClipDistances: uint32
maxCullDistances: uint32
maxCombinedClipAndCullDistances: uint32
discreteQueuePriorities: uint32
pointSizeRange: array[2, cfloat]
lineWidthRange: array[2, cfloat]
pointSizeGranularity: cfloat
lineWidthGranularity: cfloat
strictLines: VkBool32
standardSampleLocations: VkBool32
optimalBufferCopyOffsetAlignment: VkDeviceSize
optimalBufferCopyRowPitchAlignment: VkDeviceSize
nonCoherentAtomSize: VkDeviceSize
VkPhysicalDeviceSparseProperties* = object
residencyStandard2DBlockShape: VkBool32
residencyStandard2DMultisampleBlockShape: VkBool32
residencyStandard3DBlockShape: VkBool32
residencyAlignedMipSize: VkBool32
residencyNonResidentStrict: VkBool32
VkPhysicalDeviceProperties* = object
apiVersion: uint32
driverVersion: uint32
vendorID: uint32
deviceID: uint32
deviceType: VkPhysicalDeviceType
deviceName: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char]
pipelineCacheUUID: array[VK_UUID_SIZE, uint8]
limits: VkPhysicalDeviceLimits
sparseProperties: VkPhysicalDeviceSparseProperties
PFN_vkGetPhysicalDeviceProperties* = proc (
physicalDevice: VkPhysicalDevice;
pProperties: ptr VkPhysicalDeviceProperties;
): void {.cdecl.}
VkQueueFlags* = VkFlags
VkQueueFamilyProperties* = object
queueFlags: VkQueueFlags
queueCount: uint32
timestampValidBits: uint32
minImageTransferGranularity: VkExtent3D
PFN_vkGetPhysicalDeviceQueueFamilyProperties* = proc (
physicalDevice: VkPhysicalDevice;
pQueueFamilyPropertyCount: ptr uint32;
pQueueFamilyProperties: ptr VkQueueFamilyProperties;
): void {.cdecl.}
VkMemoryPropertyFlags* = VkFlags
VkMemoryType* = object
propertyFlags: VkMemoryPropertyFlags
heapIndex: uint32
const
VK_MAX_MEMORY_TYPES* = 32
type
VkMemoryHeapFlags* = VkFlags
VkMemoryHeap* = object
size: VkDeviceSize
flags: VkMemoryHeapFlags
const
VK_MAX_MEMORY_HEAPS* = 16
type
VkPhysicalDeviceMemoryProperties* = object
memoryTypeCount: uint32
memoryTypes: array[VK_MAX_MEMORY_TYPES, VkMemoryType]
memoryHeapCount: uint32
memoryHeaps: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap]
PFN_vkGetPhysicalDeviceMemoryProperties* = proc (
physicalDevice: VkPhysicalDevice;
pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties;
): void {.cdecl.}
PFN_vkVoidFunction* = proc (): void {.cdecl.}
PFN_vkGetInstanceProcAddr* = proc (
instance: VkInstance;
pName: cstring;
): PFN_vkVoidFunction {.cdecl.}
VkDevice* = VkHandle
PFN_vkGetDeviceProcAddr* = proc (
device: VkDevice;
pName: cstring;
): PFN_vkVoidFunction {.cdecl.}
VkDeviceCreateFlags* = VkFlags
VkDeviceQueueCreateFlags* = VkFlags
VkDeviceQueueCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkDeviceQueueCreateFlags
queueFamilyIndex: uint32
queueCount: uint32
pQueuePriorities: ptr cfloat
VkDeviceCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkDeviceCreateFlags
queueCreateInfoCount: uint32
pQueueCreateInfos: ptr VkDeviceQueueCreateInfo
enabledLayerCount: uint32
ppEnabledLayerNames: cstring
enabledExtensionCount: uint32
ppEnabledExtensionNames: cstring
pEnabledFeatures: ptr VkPhysicalDeviceFeatures
PFN_vkCreateDevice* = proc (
physicalDevice: VkPhysicalDevice;
pCreateInfo: ptr VkDeviceCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pDevice: ptr VkDevice;
): VkResult {.cdecl.}
PFN_vkDestroyDevice* = proc (
device: VkDevice;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
const
VK_MAX_EXTENSION_NAME_SIZE* = 256
type
VkExtensionProperties* = object
extensionName: array[VK_MAX_EXTENSION_NAME_SIZE, char]
specVersion: uint32
PFN_vkEnumerateInstanceExtensionProperties* = proc (
pLayerName: cstring;
pPropertyCount: ptr uint32;
pProperties: ptr VkExtensionProperties;
): VkResult {.cdecl.}
PFN_vkEnumerateDeviceExtensionProperties* = proc (
physicalDevice: VkPhysicalDevice;
pLayerName: cstring;
pPropertyCount: ptr uint32;
pProperties: ptr VkExtensionProperties;
): VkResult {.cdecl.}
const
VK_MAX_DESCRIPTION_SIZE* = 256
type
VkLayerProperties* = object
layerName: array[VK_MAX_EXTENSION_NAME_SIZE, char]
specVersion: uint32
implementationVersion: uint32
description: array[VK_MAX_DESCRIPTION_SIZE, char]
PFN_vkEnumerateInstanceLayerProperties* = proc (
pPropertyCount: ptr uint32;
pProperties: ptr VkLayerProperties;
): VkResult {.cdecl.}
PFN_vkEnumerateDeviceLayerProperties* = proc (
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkLayerProperties;
): VkResult {.cdecl.}
VkQueue* = VkHandle
PFN_vkGetDeviceQueue* = proc (
device: VkDevice;
queueFamilyIndex: uint32;
queueIndex: uint32;
pQueue: ptr VkQueue;
): void {.cdecl.}
VkSemaphore* = VkNonDispatchableHandle
VkPipelineStageFlags* = VkFlags
VkCommandBuffer* = VkHandle
VkSubmitInfo* = object
sType: VkStructureType
pNext: pointer
waitSemaphoreCount: uint32
pWaitSemaphores: ptr VkSemaphore
pWaitDstStageMask: ptr VkPipelineStageFlags
commandBufferCount: uint32
pCommandBuffers: ptr VkCommandBuffer
signalSemaphoreCount: uint32
pSignalSemaphores: ptr VkSemaphore
VkFence* = VkNonDispatchableHandle
PFN_vkQueueSubmit* = proc (
queue: VkQueue;
submitCount: uint32;
pSubmits: ptr VkSubmitInfo;
fence: VkFence;
): VkResult {.cdecl.}
PFN_vkQueueWaitIdle* = proc (
queue: VkQueue;
): VkResult {.cdecl.}
PFN_vkDeviceWaitIdle* = proc (
device: VkDevice;
): VkResult {.cdecl.}
VkMemoryAllocateInfo* = object
sType: VkStructureType
pNext: pointer
allocationSize: VkDeviceSize
memoryTypeIndex: uint32
VkDeviceMemory* = VkNonDispatchableHandle
PFN_vkAllocateMemory* = proc (
device: VkDevice;
pAllocateInfo: ptr VkMemoryAllocateInfo;
pAllocator: ptr VkAllocationCallbacks;
pMemory: ptr VkDeviceMemory;
): VkResult {.cdecl.}
PFN_vkFreeMemory* = proc (
device: VkDevice;
memory: VkDeviceMemory;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkMemoryMapFlags* = VkFlags
PFN_vkMapMemory* = proc (
device: VkDevice;
memory: VkDeviceMemory;
offset: VkDeviceSize;
size: VkDeviceSize;
flags: VkMemoryMapFlags;
ppData: pointer;
): VkResult {.cdecl.}
PFN_vkUnmapMemory* = proc (
device: VkDevice;
memory: VkDeviceMemory;
): void {.cdecl.}
VkMappedMemoryRange* = object
sType: VkStructureType
pNext: pointer
memory: VkDeviceMemory
offset: VkDeviceSize
size: VkDeviceSize
PFN_vkFlushMappedMemoryRanges* = proc (
device: VkDevice;
memoryRangeCount: uint32;
pMemoryRanges: ptr VkMappedMemoryRange;
): VkResult {.cdecl.}
PFN_vkInvalidateMappedMemoryRanges* = proc (
device: VkDevice;
memoryRangeCount: uint32;
pMemoryRanges: ptr VkMappedMemoryRange;
): VkResult {.cdecl.}
PFN_vkGetDeviceMemoryCommitment* = proc (
device: VkDevice;
memory: VkDeviceMemory;
pCommittedMemoryInBytes: ptr VkDeviceSize;
): void {.cdecl.}
VkBuffer* = VkNonDispatchableHandle
PFN_vkBindBufferMemory* = proc (
device: VkDevice;
buffer: VkBuffer;
memory: VkDeviceMemory;
memoryOffset: VkDeviceSize;
): VkResult {.cdecl.}
VkImage* = VkNonDispatchableHandle
PFN_vkBindImageMemory* = proc (
device: VkDevice;
image: VkImage;
memory: VkDeviceMemory;
memoryOffset: VkDeviceSize;
): VkResult {.cdecl.}
VkMemoryRequirements* = object
size: VkDeviceSize
alignment: VkDeviceSize
memoryTypeBits: uint32
PFN_vkGetBufferMemoryRequirements* = proc (
device: VkDevice;
buffer: VkBuffer;
pMemoryRequirements: ptr VkMemoryRequirements;
): void {.cdecl.}
PFN_vkGetImageMemoryRequirements* = proc (
device: VkDevice;
image: VkImage;
pMemoryRequirements: ptr VkMemoryRequirements;
): void {.cdecl.}
VkImageAspectFlags* = VkFlags
VkSparseImageFormatFlags* = VkFlags
VkSparseImageFormatProperties* = object
aspectMask: VkImageAspectFlags
imageGranularity: VkExtent3D
flags: VkSparseImageFormatFlags
VkSparseImageMemoryRequirements* = object
formatProperties: VkSparseImageFormatProperties
imageMipTailFirstLod: uint32
imageMipTailSize: VkDeviceSize
imageMipTailOffset: VkDeviceSize
imageMipTailStride: VkDeviceSize
PFN_vkGetImageSparseMemoryRequirements* = proc (
device: VkDevice;
image: VkImage;
pSparseMemoryRequirementCount: ptr uint32;
pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements;
): void {.cdecl.}
VkSampleCountFlagBits* {.size: sizeof(cint).} = enum
VK_SAMPLE_COUNT_1_BIT = 0x00000001
VK_SAMPLE_COUNT_2_BIT = 0x00000002
VK_SAMPLE_COUNT_4_BIT = 0x00000004
VK_SAMPLE_COUNT_8_BIT = 0x00000008
VK_SAMPLE_COUNT_16_BIT = 0x00000010
VK_SAMPLE_COUNT_32_BIT = 0x00000020
VK_SAMPLE_COUNT_64_BIT = 0x00000040
PFN_vkGetPhysicalDeviceSparseImageFormatProperties* = proc (
physicalDevice: VkPhysicalDevice;
format: VkFormat;
theType: VkImageType;
samples: VkSampleCountFlagBits;
usage: VkImageUsageFlags;
tiling: VkImageTiling;
pPropertyCount: ptr uint32;
pProperties: ptr VkSparseImageFormatProperties;
): void {.cdecl.}
VkSparseMemoryBindFlags* = VkFlags
VkSparseMemoryBind* = object
resourceOffset: VkDeviceSize
size: VkDeviceSize
memory: VkDeviceMemory
memoryOffset: VkDeviceSize
flags: VkSparseMemoryBindFlags
VkSparseBufferMemoryBindInfo* = object
buffer: VkBuffer
bindCount: uint32
pBinds: ptr VkSparseMemoryBind
VkSparseImageOpaqueMemoryBindInfo* = object
image: VkImage
bindCount: uint32
pBinds: ptr VkSparseMemoryBind
VkImageSubresource* = object
aspectMask: VkImageAspectFlags
mipLevel: uint32
arrayLayer: uint32
VkOffset3D* = object
x: int32
y: int32
z: int32
VkSparseImageMemoryBind* = object
subresource: VkImageSubresource
offset: VkOffset3D
extent: VkExtent3D
memory: VkDeviceMemory
memoryOffset: VkDeviceSize
flags: VkSparseMemoryBindFlags
VkSparseImageMemoryBindInfo* = object
image: VkImage
bindCount: uint32
pBinds: ptr VkSparseImageMemoryBind
VkBindSparseInfo* = object
sType: VkStructureType
pNext: pointer
waitSemaphoreCount: uint32
pWaitSemaphores: ptr VkSemaphore
bufferBindCount: uint32
pBufferBinds: ptr VkSparseBufferMemoryBindInfo
imageOpaqueBindCount: uint32
pImageOpaqueBinds: ptr VkSparseImageOpaqueMemoryBindInfo
imageBindCount: uint32
pImageBinds: ptr VkSparseImageMemoryBindInfo
signalSemaphoreCount: uint32
pSignalSemaphores: ptr VkSemaphore
PFN_vkQueueBindSparse* = proc (
queue: VkQueue;
bindInfoCount: uint32;
pBindInfo: ptr VkBindSparseInfo;
fence: VkFence;
): VkResult {.cdecl.}
VkFenceCreateFlags* = VkFlags
VkFenceCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkFenceCreateFlags
PFN_vkCreateFence* = proc (
device: VkDevice;
pCreateInfo: ptr VkFenceCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pFence: ptr VkFence;
): VkResult {.cdecl.}
PFN_vkDestroyFence* = proc (
device: VkDevice;
fence: VkFence;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkResetFences* = proc (
device: VkDevice;
fenceCount: uint32;
pFences: ptr VkFence;
): VkResult {.cdecl.}
PFN_vkGetFenceStatus* = proc (
device: VkDevice;
fence: VkFence;
): VkResult {.cdecl.}
PFN_vkWaitForFences* = proc (
device: VkDevice;
fenceCount: uint32;
pFences: ptr VkFence;
waitAll: VkBool32;
timeout: uint64;
): VkResult {.cdecl.}
VkSemaphoreCreateFlags* = VkFlags
VkSemaphoreCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkSemaphoreCreateFlags
PFN_vkCreateSemaphore* = proc (
device: VkDevice;
pCreateInfo: ptr VkSemaphoreCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pSemaphore: ptr VkSemaphore;
): VkResult {.cdecl.}
PFN_vkDestroySemaphore* = proc (
device: VkDevice;
semaphore: VkSemaphore;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkEventCreateFlags* = VkFlags
VkEventCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkEventCreateFlags
VkEvent* = VkNonDispatchableHandle
PFN_vkCreateEvent* = proc (
device: VkDevice;
pCreateInfo: ptr VkEventCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pEvent: ptr VkEvent;
): VkResult {.cdecl.}
PFN_vkDestroyEvent* = proc (
device: VkDevice;
event: VkEvent;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkGetEventStatus* = proc (
device: VkDevice;
event: VkEvent;
): VkResult {.cdecl.}
PFN_vkSetEvent* = proc (
device: VkDevice;
event: VkEvent;
): VkResult {.cdecl.}
PFN_vkResetEvent* = proc (
device: VkDevice;
event: VkEvent;
): VkResult {.cdecl.}
VkQueryPoolCreateFlags* = VkFlags
VkQueryType* {.size: sizeof(cint).} = enum
VK_QUERY_TYPE_OCCLUSION = 0
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1
VK_QUERY_TYPE_TIMESTAMP = 2
VK_QUERY_TYPE_COMPACTED_SIZE_NVX = 1000165000
VkQueryPipelineStatisticFlags* = VkFlags
VkQueryPoolCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkQueryPoolCreateFlags
queryType: VkQueryType
queryCount: uint32
pipelineStatistics: VkQueryPipelineStatisticFlags
VkQueryPool* = VkNonDispatchableHandle
PFN_vkCreateQueryPool* = proc (
device: VkDevice;
pCreateInfo: ptr VkQueryPoolCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pQueryPool: ptr VkQueryPool;
): VkResult {.cdecl.}
PFN_vkDestroyQueryPool* = proc (
device: VkDevice;
queryPool: VkQueryPool;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkQueryResultFlags* = VkFlags
PFN_vkGetQueryPoolResults* = proc (
device: VkDevice;
queryPool: VkQueryPool;
firstQuery: uint32;
queryCount: uint32;
dataSize: csize;
pData: pointer;
stride: VkDeviceSize;
flags: VkQueryResultFlags;
): VkResult {.cdecl.}
VkBufferCreateFlags* = VkFlags
VkBufferUsageFlags* = VkFlags
VkSharingMode* {.size: sizeof(cint).} = enum
VK_SHARING_MODE_EXCLUSIVE = 0
VK_SHARING_MODE_CONCURRENT = 1
VkBufferCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkBufferCreateFlags
size: VkDeviceSize
usage: VkBufferUsageFlags
sharingMode: VkSharingMode
queueFamilyIndexCount: uint32
pQueueFamilyIndices: ptr uint32
PFN_vkCreateBuffer* = proc (
device: VkDevice;
pCreateInfo: ptr VkBufferCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pBuffer: ptr VkBuffer;
): VkResult {.cdecl.}
PFN_vkDestroyBuffer* = proc (
device: VkDevice;
buffer: VkBuffer;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkBufferViewCreateFlags* = VkFlags
VkBufferViewCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkBufferViewCreateFlags
buffer: VkBuffer
format: VkFormat
offset: VkDeviceSize
range: VkDeviceSize
VkBufferView* = VkNonDispatchableHandle
PFN_vkCreateBufferView* = proc (
device: VkDevice;
pCreateInfo: ptr VkBufferViewCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pView: ptr VkBufferView;
): VkResult {.cdecl.}
PFN_vkDestroyBufferView* = proc (
device: VkDevice;
bufferView: VkBufferView;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkImageLayout* {.size: sizeof(cint).} = enum
VK_IMAGE_LAYOUT_UNDEFINED = 0
VK_IMAGE_LAYOUT_GENERAL = 1
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7
VK_IMAGE_LAYOUT_PREINITIALIZED = 8
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002
VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000
VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000
VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001
VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003
VkImageCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkImageCreateFlags
imageType: VkImageType
format: VkFormat
extent: VkExtent3D
mipLevels: uint32
arrayLayers: uint32
samples: VkSampleCountFlagBits
tiling: VkImageTiling
usage: VkImageUsageFlags
sharingMode: VkSharingMode
queueFamilyIndexCount: uint32
pQueueFamilyIndices: ptr uint32
initialLayout: VkImageLayout
PFN_vkCreateImage* = proc (
device: VkDevice;
pCreateInfo: ptr VkImageCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pImage: ptr VkImage;
): VkResult {.cdecl.}
PFN_vkDestroyImage* = proc (
device: VkDevice;
image: VkImage;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkSubresourceLayout* = object
offset: VkDeviceSize
size: VkDeviceSize
rowPitch: VkDeviceSize
arrayPitch: VkDeviceSize
depthPitch: VkDeviceSize
PFN_vkGetImageSubresourceLayout* = proc (
device: VkDevice;
image: VkImage;
pSubresource: ptr VkImageSubresource;
pLayout: ptr VkSubresourceLayout;
): void {.cdecl.}
VkImageViewCreateFlags* = VkFlags
VkImageViewType* {.size: sizeof(cint).} = enum
VK_IMAGE_VIEW_TYPE_1D = 0
VK_IMAGE_VIEW_TYPE_2D = 1
VK_IMAGE_VIEW_TYPE_3D = 2
VK_IMAGE_VIEW_TYPE_CUBE = 3
VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4
VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6
VkComponentSwizzle* {.size: sizeof(cint).} = enum
VK_COMPONENT_SWIZZLE_IDENTITY = 0
VK_COMPONENT_SWIZZLE_ZERO = 1
VK_COMPONENT_SWIZZLE_ONE = 2
VK_COMPONENT_SWIZZLE_R = 3
VK_COMPONENT_SWIZZLE_G = 4
VK_COMPONENT_SWIZZLE_B = 5
VK_COMPONENT_SWIZZLE_A = 6
VkComponentMapping* = object
r: VkComponentSwizzle
g: VkComponentSwizzle
b: VkComponentSwizzle
a: VkComponentSwizzle
VkImageSubresourceRange* = object
aspectMask: VkImageAspectFlags
baseMipLevel: uint32
levelCount: uint32
baseArrayLayer: uint32
layerCount: uint32
VkImageViewCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkImageViewCreateFlags
image: VkImage
viewType: VkImageViewType
format: VkFormat
components: VkComponentMapping
subresourceRange: VkImageSubresourceRange
VkImageView* = VkNonDispatchableHandle
PFN_vkCreateImageView* = proc (
device: VkDevice;
pCreateInfo: ptr VkImageViewCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pView: ptr VkImageView;
): VkResult {.cdecl.}
PFN_vkDestroyImageView* = proc (
device: VkDevice;
imageView: VkImageView;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkShaderModuleCreateFlags* = VkFlags
VkShaderModuleCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkShaderModuleCreateFlags
codeSize: csize
pCode: ptr uint32
VkShaderModule* = VkNonDispatchableHandle
PFN_vkCreateShaderModule* = proc (
device: VkDevice;
pCreateInfo: ptr VkShaderModuleCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pShaderModule: ptr VkShaderModule;
): VkResult {.cdecl.}
PFN_vkDestroyShaderModule* = proc (
device: VkDevice;
shaderModule: VkShaderModule;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkPipelineCacheCreateFlags* = VkFlags
VkPipelineCacheCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineCacheCreateFlags
initialDataSize: csize
pInitialData: pointer
VkPipelineCache* = VkNonDispatchableHandle
PFN_vkCreatePipelineCache* = proc (
device: VkDevice;
pCreateInfo: ptr VkPipelineCacheCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelineCache: ptr VkPipelineCache;
): VkResult {.cdecl.}
PFN_vkDestroyPipelineCache* = proc (
device: VkDevice;
pipelineCache: VkPipelineCache;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkGetPipelineCacheData* = proc (
device: VkDevice;
pipelineCache: VkPipelineCache;
pDataSize: ptr csize;
pData: pointer;
): VkResult {.cdecl.}
PFN_vkMergePipelineCaches* = proc (
device: VkDevice;
dstCache: VkPipelineCache;
srcCacheCount: uint32;
pSrcCaches: ptr VkPipelineCache;
): VkResult {.cdecl.}
VkPipelineCreateFlags* = VkFlags
VkPipelineShaderStageCreateFlags* = VkFlags
VkShaderStageFlagBits* {.size: sizeof(cint).} = enum
VK_SHADER_STAGE_VERTEX_BIT = 0x00000001
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004
VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008
VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010
VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F
VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020
VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040
VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080
VK_SHADER_STAGE_RAYGEN_BIT_NVX = 0x00000100
VK_SHADER_STAGE_ANY_HIT_BIT_NVX = 0x00000200
VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX = 0x00000400
VK_SHADER_STAGE_MISS_BIT_NVX = 0x00000800
VK_SHADER_STAGE_INTERSECTION_BIT_NVX = 0x00001000
VK_SHADER_STAGE_CALLABLE_BIT_NVX = 0x00002000
VK_SHADER_STAGE_ALL = 0x7FFFFFFF
VkSpecializationMapEntry* = object
constantID: uint32
offset: uint32
size: csize
VkSpecializationInfo* = object
mapEntryCount: uint32
pMapEntries: ptr VkSpecializationMapEntry
dataSize: csize
pData: pointer
VkPipelineShaderStageCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineShaderStageCreateFlags
stage: VkShaderStageFlagBits
module: VkShaderModule
pName: cstring
pSpecializationInfo: ptr VkSpecializationInfo
VkPipelineVertexInputStateCreateFlags* = VkFlags
VkVertexInputRate* {.size: sizeof(cint).} = enum
VK_VERTEX_INPUT_RATE_VERTEX = 0
VK_VERTEX_INPUT_RATE_INSTANCE = 1
VkVertexInputBindingDescription* = object
binding: uint32
stride: uint32
inputRate: VkVertexInputRate
VkVertexInputAttributeDescription* = object
location: uint32
binding: uint32
format: VkFormat
offset: uint32
VkPipelineVertexInputStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineVertexInputStateCreateFlags
vertexBindingDescriptionCount: uint32
pVertexBindingDescriptions: ptr VkVertexInputBindingDescription
vertexAttributeDescriptionCount: uint32
pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription
VkPipelineInputAssemblyStateCreateFlags* = VkFlags
VkPrimitiveTopology* {.size: sizeof(cint).} = enum
VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0
VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9
VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10
VkPipelineInputAssemblyStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineInputAssemblyStateCreateFlags
topology: VkPrimitiveTopology
primitiveRestartEnable: VkBool32
VkPipelineTessellationStateCreateFlags* = VkFlags
VkPipelineTessellationStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineTessellationStateCreateFlags
patchControlPoints: uint32
VkPipelineViewportStateCreateFlags* = VkFlags
VkViewport* = object
x: cfloat
y: cfloat
width: cfloat
height: cfloat
minDepth: cfloat
maxDepth: cfloat
VkOffset2D* = object
x: int32
y: int32
VkExtent2D* = object
width: uint32
height: uint32
VkRect2D* = object
offset: VkOffset2D
extent: VkExtent2D
VkPipelineViewportStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineViewportStateCreateFlags
viewportCount: uint32
pViewports: ptr VkViewport
scissorCount: uint32
pScissors: ptr VkRect2D
VkPipelineRasterizationStateCreateFlags* = VkFlags
VkPolygonMode* {.size: sizeof(cint).} = enum
VK_POLYGON_MODE_FILL = 0
VK_POLYGON_MODE_LINE = 1
VK_POLYGON_MODE_POINT = 2
VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000
VkCullModeFlags* = VkFlags
VkFrontFace* {.size: sizeof(cint).} = enum
VK_FRONT_FACE_COUNTER_CLOCKWISE = 0
VK_FRONT_FACE_CLOCKWISE = 1
VkPipelineRasterizationStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineRasterizationStateCreateFlags
depthClampEnable: VkBool32
rasterizerDiscardEnable: VkBool32
polygonMode: VkPolygonMode
cullMode: VkCullModeFlags
frontFace: VkFrontFace
depthBiasEnable: VkBool32
depthBiasConstantFactor: cfloat
depthBiasClamp: cfloat
depthBiasSlopeFactor: cfloat
lineWidth: cfloat
VkPipelineMultisampleStateCreateFlags* = VkFlags
VkSampleMask* = uint32
VkPipelineMultisampleStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineMultisampleStateCreateFlags
rasterizationSamples: VkSampleCountFlagBits
sampleShadingEnable: VkBool32
minSampleShading: cfloat
pSampleMask: ptr VkSampleMask
alphaToCoverageEnable: VkBool32
alphaToOneEnable: VkBool32
VkPipelineDepthStencilStateCreateFlags* = VkFlags
VkCompareOp* {.size: sizeof(cint).} = enum
VK_COMPARE_OP_NEVER = 0
VK_COMPARE_OP_LESS = 1
VK_COMPARE_OP_EQUAL = 2
VK_COMPARE_OP_LESS_OR_EQUAL = 3
VK_COMPARE_OP_GREATER = 4
VK_COMPARE_OP_NOT_EQUAL = 5
VK_COMPARE_OP_GREATER_OR_EQUAL = 6
VK_COMPARE_OP_ALWAYS = 7
VkStencilOp* {.size: sizeof(cint).} = enum
VK_STENCIL_OP_KEEP = 0
VK_STENCIL_OP_ZERO = 1
VK_STENCIL_OP_REPLACE = 2
VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3
VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4
VK_STENCIL_OP_INVERT = 5
VK_STENCIL_OP_INCREMENT_AND_WRAP = 6
VK_STENCIL_OP_DECREMENT_AND_WRAP = 7
VkStencilOpState* = object
failOp: VkStencilOp
passOp: VkStencilOp
depthFailOp: VkStencilOp
compareOp: VkCompareOp
compareMask: uint32
writeMask: uint32
reference: uint32
VkPipelineDepthStencilStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineDepthStencilStateCreateFlags
depthTestEnable: VkBool32
depthWriteEnable: VkBool32
depthCompareOp: VkCompareOp
depthBoundsTestEnable: VkBool32
stencilTestEnable: VkBool32
front: VkStencilOpState
back: VkStencilOpState
minDepthBounds: cfloat
maxDepthBounds: cfloat
VkPipelineColorBlendStateCreateFlags* = VkFlags
VkLogicOp* {.size: sizeof(cint).} = enum
VK_LOGIC_OP_CLEAR = 0
VK_LOGIC_OP_AND = 1
VK_LOGIC_OP_AND_REVERSE = 2
VK_LOGIC_OP_COPY = 3
VK_LOGIC_OP_AND_INVERTED = 4
VK_LOGIC_OP_NO_OP = 5
VK_LOGIC_OP_XOR = 6
VK_LOGIC_OP_OR = 7
VK_LOGIC_OP_NOR = 8
VK_LOGIC_OP_EQUIVALENT = 9
VK_LOGIC_OP_INVERT = 10
VK_LOGIC_OP_OR_REVERSE = 11
VK_LOGIC_OP_COPY_INVERTED = 12
VK_LOGIC_OP_OR_INVERTED = 13
VK_LOGIC_OP_NAND = 14
VK_LOGIC_OP_SET = 15
VkBlendFactor* {.size: sizeof(cint).} = enum
VK_BLEND_FACTOR_ZERO = 0
VK_BLEND_FACTOR_ONE = 1
VK_BLEND_FACTOR_SRC_COLOR = 2
VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3
VK_BLEND_FACTOR_DST_COLOR = 4
VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5
VK_BLEND_FACTOR_SRC_ALPHA = 6
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7
VK_BLEND_FACTOR_DST_ALPHA = 8
VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9
VK_BLEND_FACTOR_CONSTANT_COLOR = 10
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11
VK_BLEND_FACTOR_CONSTANT_ALPHA = 12
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13
VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14
VK_BLEND_FACTOR_SRC1_COLOR = 15
VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16
VK_BLEND_FACTOR_SRC1_ALPHA = 17
VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18
VkBlendOp* {.size: sizeof(cint).} = enum
VK_BLEND_OP_ADD = 0
VK_BLEND_OP_SUBTRACT = 1
VK_BLEND_OP_REVERSE_SUBTRACT = 2
VK_BLEND_OP_MIN = 3
VK_BLEND_OP_MAX = 4
VK_BLEND_OP_ZERO_EXT = 1000148000
VK_BLEND_OP_SRC_EXT = 1000148001
VK_BLEND_OP_DST_EXT = 1000148002
VK_BLEND_OP_SRC_OVER_EXT = 1000148003
VK_BLEND_OP_DST_OVER_EXT = 1000148004
VK_BLEND_OP_SRC_IN_EXT = 1000148005
VK_BLEND_OP_DST_IN_EXT = 1000148006
VK_BLEND_OP_SRC_OUT_EXT = 1000148007
VK_BLEND_OP_DST_OUT_EXT = 1000148008
VK_BLEND_OP_SRC_ATOP_EXT = 1000148009
VK_BLEND_OP_DST_ATOP_EXT = 1000148010
VK_BLEND_OP_XOR_EXT = 1000148011
VK_BLEND_OP_MULTIPLY_EXT = 1000148012
VK_BLEND_OP_SCREEN_EXT = 1000148013
VK_BLEND_OP_OVERLAY_EXT = 1000148014
VK_BLEND_OP_DARKEN_EXT = 1000148015
VK_BLEND_OP_LIGHTEN_EXT = 1000148016
VK_BLEND_OP_COLORDODGE_EXT = 1000148017
VK_BLEND_OP_COLORBURN_EXT = 1000148018
VK_BLEND_OP_HARDLIGHT_EXT = 1000148019
VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020
VK_BLEND_OP_DIFFERENCE_EXT = 1000148021
VK_BLEND_OP_EXCLUSION_EXT = 1000148022
VK_BLEND_OP_INVERT_EXT = 1000148023
VK_BLEND_OP_INVERT_RGB_EXT = 1000148024
VK_BLEND_OP_LINEARDODGE_EXT = 1000148025
VK_BLEND_OP_LINEARBURN_EXT = 1000148026
VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027
VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028
VK_BLEND_OP_PINLIGHT_EXT = 1000148029
VK_BLEND_OP_HARDMIX_EXT = 1000148030
VK_BLEND_OP_HSL_HUE_EXT = 1000148031
VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032
VK_BLEND_OP_HSL_COLOR_EXT = 1000148033
VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034
VK_BLEND_OP_PLUS_EXT = 1000148035
VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036
VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037
VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038
VK_BLEND_OP_MINUS_EXT = 1000148039
VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040
VK_BLEND_OP_CONTRAST_EXT = 1000148041
VK_BLEND_OP_INVERT_OVG_EXT = 1000148042
VK_BLEND_OP_RED_EXT = 1000148043
VK_BLEND_OP_GREEN_EXT = 1000148044
VK_BLEND_OP_BLUE_EXT = 1000148045
VkColorComponentFlags* = VkFlags
VkPipelineColorBlendAttachmentState* = object
blendEnable: VkBool32
srcColorBlendFactor: VkBlendFactor
dstColorBlendFactor: VkBlendFactor
colorBlendOp: VkBlendOp
srcAlphaBlendFactor: VkBlendFactor
dstAlphaBlendFactor: VkBlendFactor
alphaBlendOp: VkBlendOp
colorWriteMask: VkColorComponentFlags
VkPipelineColorBlendStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineColorBlendStateCreateFlags
logicOpEnable: VkBool32
logicOp: VkLogicOp
attachmentCount: uint32
pAttachments: ptr VkPipelineColorBlendAttachmentState
blendConstants: array[4, cfloat]
VkPipelineDynamicStateCreateFlags* = VkFlags
VkDynamicState* {.size: sizeof(cint).} = enum
VK_DYNAMIC_STATE_VIEWPORT = 0
VK_DYNAMIC_STATE_SCISSOR = 1
VK_DYNAMIC_STATE_LINE_WIDTH = 2
VK_DYNAMIC_STATE_DEPTH_BIAS = 3
VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4
VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5
VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6
VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7
VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8
VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000
VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000
VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000
VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004
VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001
VkPipelineDynamicStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineDynamicStateCreateFlags
dynamicStateCount: uint32
pDynamicStates: ptr VkDynamicState
VkPipelineLayout* = VkNonDispatchableHandle
VkRenderPass* = VkNonDispatchableHandle
VkPipeline* = VkNonDispatchableHandle
VkGraphicsPipelineCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineCreateFlags
stageCount: uint32
pStages: ptr VkPipelineShaderStageCreateInfo
pVertexInputState: ptr VkPipelineVertexInputStateCreateInfo
pInputAssemblyState: ptr VkPipelineInputAssemblyStateCreateInfo
pTessellationState: ptr VkPipelineTessellationStateCreateInfo
pViewportState: ptr VkPipelineViewportStateCreateInfo
pRasterizationState: ptr VkPipelineRasterizationStateCreateInfo
pMultisampleState: ptr VkPipelineMultisampleStateCreateInfo
pDepthStencilState: ptr VkPipelineDepthStencilStateCreateInfo
pColorBlendState: ptr VkPipelineColorBlendStateCreateInfo
pDynamicState: ptr VkPipelineDynamicStateCreateInfo
layout: VkPipelineLayout
renderPass: VkRenderPass
subpass: uint32
basePipelineHandle: VkPipeline
basePipelineIndex: int32
PFN_vkCreateGraphicsPipelines* = proc (
device: VkDevice;
pipelineCache: VkPipelineCache;
createInfoCount: uint32;
pCreateInfos: ptr VkGraphicsPipelineCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelines: ptr VkPipeline;
): VkResult {.cdecl.}
VkComputePipelineCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineCreateFlags
stage: VkPipelineShaderStageCreateInfo
layout: VkPipelineLayout
basePipelineHandle: VkPipeline
basePipelineIndex: int32
PFN_vkCreateComputePipelines* = proc (
device: VkDevice;
pipelineCache: VkPipelineCache;
createInfoCount: uint32;
pCreateInfos: ptr VkComputePipelineCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelines: ptr VkPipeline;
): VkResult {.cdecl.}
PFN_vkDestroyPipeline* = proc (
device: VkDevice;
pipeline: VkPipeline;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkPipelineLayoutCreateFlags* = VkFlags
VkDescriptorSetLayout* = VkNonDispatchableHandle
VkShaderStageFlags* = VkFlags
VkPushConstantRange* = object
stageFlags: VkShaderStageFlags
offset: uint32
size: uint32
VkPipelineLayoutCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineLayoutCreateFlags
setLayoutCount: uint32
pSetLayouts: ptr VkDescriptorSetLayout
pushConstantRangeCount: uint32
pPushConstantRanges: ptr VkPushConstantRange
PFN_vkCreatePipelineLayout* = proc (
device: VkDevice;
pCreateInfo: ptr VkPipelineLayoutCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelineLayout: ptr VkPipelineLayout;
): VkResult {.cdecl.}
PFN_vkDestroyPipelineLayout* = proc (
device: VkDevice;
pipelineLayout: VkPipelineLayout;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkSamplerCreateFlags* = VkFlags
VkFilter* {.size: sizeof(cint).} = enum
VK_FILTER_NEAREST = 0
VK_FILTER_LINEAR = 1
VK_FILTER_CUBIC_IMG = 1000015000
VkSamplerMipmapMode* {.size: sizeof(cint).} = enum
VK_SAMPLER_MIPMAP_MODE_NEAREST = 0
VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
VkSamplerAddressMode* {.size: sizeof(cint).} = enum
VK_SAMPLER_ADDRESS_MODE_REPEAT = 0
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4
VkBorderColor* {.size: sizeof(cint).} = enum
VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0
VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1
VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2
VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3
VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4
VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5
VkSamplerCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkSamplerCreateFlags
magFilter: VkFilter
minFilter: VkFilter
mipmapMode: VkSamplerMipmapMode
addressModeU: VkSamplerAddressMode
addressModeV: VkSamplerAddressMode
addressModeW: VkSamplerAddressMode
mipLodBias: cfloat
anisotropyEnable: VkBool32
maxAnisotropy: cfloat
compareEnable: VkBool32
compareOp: VkCompareOp
minLod: cfloat
maxLod: cfloat
borderColor: VkBorderColor
unnormalizedCoordinates: VkBool32
VkSampler* = VkNonDispatchableHandle
PFN_vkCreateSampler* = proc (
device: VkDevice;
pCreateInfo: ptr VkSamplerCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pSampler: ptr VkSampler;
): VkResult {.cdecl.}
PFN_vkDestroySampler* = proc (
device: VkDevice;
sampler: VkSampler;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkDescriptorSetLayoutCreateFlags* = VkFlags
VkDescriptorType* {.size: sizeof(cint).} = enum
VK_DESCRIPTOR_TYPE_SAMPLER = 0
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3
VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10
VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000
VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX = 1000165000
VkDescriptorSetLayoutBinding* = object
binding: uint32
descriptorType: VkDescriptorType
descriptorCount: uint32
stageFlags: VkShaderStageFlags
pImmutableSamplers: ptr VkSampler
VkDescriptorSetLayoutCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkDescriptorSetLayoutCreateFlags
bindingCount: uint32
pBindings: ptr VkDescriptorSetLayoutBinding
PFN_vkCreateDescriptorSetLayout* = proc (
device: VkDevice;
pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pSetLayout: ptr VkDescriptorSetLayout;
): VkResult {.cdecl.}
PFN_vkDestroyDescriptorSetLayout* = proc (
device: VkDevice;
descriptorSetLayout: VkDescriptorSetLayout;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkDescriptorPoolCreateFlags* = VkFlags
VkDescriptorPoolSize* = object
theType: VkDescriptorType
descriptorCount: uint32
VkDescriptorPoolCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkDescriptorPoolCreateFlags
maxSets: uint32
poolSizeCount: uint32
pPoolSizes: ptr VkDescriptorPoolSize
VkDescriptorPool* = VkNonDispatchableHandle
PFN_vkCreateDescriptorPool* = proc (
device: VkDevice;
pCreateInfo: ptr VkDescriptorPoolCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pDescriptorPool: ptr VkDescriptorPool;
): VkResult {.cdecl.}
PFN_vkDestroyDescriptorPool* = proc (
device: VkDevice;
descriptorPool: VkDescriptorPool;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkDescriptorPoolResetFlags* = VkFlags
PFN_vkResetDescriptorPool* = proc (
device: VkDevice;
descriptorPool: VkDescriptorPool;
flags: VkDescriptorPoolResetFlags;
): VkResult {.cdecl.}
VkDescriptorSetAllocateInfo* = object
sType: VkStructureType
pNext: pointer
descriptorPool: VkDescriptorPool
descriptorSetCount: uint32
pSetLayouts: ptr VkDescriptorSetLayout
VkDescriptorSet* = VkNonDispatchableHandle
PFN_vkAllocateDescriptorSets* = proc (
device: VkDevice;
pAllocateInfo: ptr VkDescriptorSetAllocateInfo;
pDescriptorSets: ptr VkDescriptorSet;
): VkResult {.cdecl.}
PFN_vkFreeDescriptorSets* = proc (
device: VkDevice;
descriptorPool: VkDescriptorPool;
descriptorSetCount: uint32;
pDescriptorSets: ptr VkDescriptorSet;
): VkResult {.cdecl.}
VkDescriptorImageInfo* = object
sampler: VkSampler
imageView: VkImageView
imageLayout: VkImageLayout
VkDescriptorBufferInfo* = object
buffer: VkBuffer
offset: VkDeviceSize
range: VkDeviceSize
VkWriteDescriptorSet* = object
sType: VkStructureType
pNext: pointer
dstSet: VkDescriptorSet
dstBinding: uint32
dstArrayElement: uint32
descriptorCount: uint32
descriptorType: VkDescriptorType
pImageInfo: ptr VkDescriptorImageInfo
pBufferInfo: ptr VkDescriptorBufferInfo
pTexelBufferView: ptr VkBufferView
VkCopyDescriptorSet* = object
sType: VkStructureType
pNext: pointer
srcSet: VkDescriptorSet
srcBinding: uint32
srcArrayElement: uint32
dstSet: VkDescriptorSet
dstBinding: uint32
dstArrayElement: uint32
descriptorCount: uint32
PFN_vkUpdateDescriptorSets* = proc (
device: VkDevice;
descriptorWriteCount: uint32;
pDescriptorWrites: ptr VkWriteDescriptorSet;
descriptorCopyCount: uint32;
pDescriptorCopies: ptr VkCopyDescriptorSet;
): void {.cdecl.}
VkFramebufferCreateFlags* = VkFlags
VkFramebufferCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkFramebufferCreateFlags
renderPass: VkRenderPass
attachmentCount: uint32
pAttachments: ptr VkImageView
width: uint32
height: uint32
layers: uint32
VkFramebuffer* = VkNonDispatchableHandle
PFN_vkCreateFramebuffer* = proc (
device: VkDevice;
pCreateInfo: ptr VkFramebufferCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pFramebuffer: ptr VkFramebuffer;
): VkResult {.cdecl.}
PFN_vkDestroyFramebuffer* = proc (
device: VkDevice;
framebuffer: VkFramebuffer;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkRenderPassCreateFlags* = VkFlags
VkAttachmentDescriptionFlags* = VkFlags
VkAttachmentLoadOp* {.size: sizeof(cint).} = enum
VK_ATTACHMENT_LOAD_OP_LOAD = 0
VK_ATTACHMENT_LOAD_OP_CLEAR = 1
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
VkAttachmentStoreOp* {.size: sizeof(cint).} = enum
VK_ATTACHMENT_STORE_OP_STORE = 0
VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
VkAttachmentDescription* = object
flags: VkAttachmentDescriptionFlags
format: VkFormat
samples: VkSampleCountFlagBits
loadOp: VkAttachmentLoadOp
storeOp: VkAttachmentStoreOp
stencilLoadOp: VkAttachmentLoadOp
stencilStoreOp: VkAttachmentStoreOp
initialLayout: VkImageLayout
finalLayout: VkImageLayout
VkSubpassDescriptionFlags* = VkFlags
VkPipelineBindPoint* {.size: sizeof(cint).} = enum
VK_PIPELINE_BIND_POINT_GRAPHICS = 0
VK_PIPELINE_BIND_POINT_COMPUTE = 1
VK_PIPELINE_BIND_POINT_RAYTRACING_NVX = 1000165000
VkAttachmentReference* = object
attachment: uint32
layout: VkImageLayout
VkSubpassDescription* = object
flags: VkSubpassDescriptionFlags
pipelineBindPoint: VkPipelineBindPoint
inputAttachmentCount: uint32
pInputAttachments: ptr VkAttachmentReference
colorAttachmentCount: uint32
pColorAttachments: ptr VkAttachmentReference
pResolveAttachments: ptr VkAttachmentReference
pDepthStencilAttachment: ptr VkAttachmentReference
preserveAttachmentCount: uint32
pPreserveAttachments: ptr uint32
VkAccessFlags* = VkFlags
VkDependencyFlags* = VkFlags
VkSubpassDependency* = object
srcSubpass: uint32
dstSubpass: uint32
srcStageMask: VkPipelineStageFlags
dstStageMask: VkPipelineStageFlags
srcAccessMask: VkAccessFlags
dstAccessMask: VkAccessFlags
dependencyFlags: VkDependencyFlags
VkRenderPassCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkRenderPassCreateFlags
attachmentCount: uint32
pAttachments: ptr VkAttachmentDescription
subpassCount: uint32
pSubpasses: ptr VkSubpassDescription
dependencyCount: uint32
pDependencies: ptr VkSubpassDependency
PFN_vkCreateRenderPass* = proc (
device: VkDevice;
pCreateInfo: ptr VkRenderPassCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pRenderPass: ptr VkRenderPass;
): VkResult {.cdecl.}
PFN_vkDestroyRenderPass* = proc (
device: VkDevice;
renderPass: VkRenderPass;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkGetRenderAreaGranularity* = proc (
device: VkDevice;
renderPass: VkRenderPass;
pGranularity: ptr VkExtent2D;
): void {.cdecl.}
VkCommandPoolCreateFlags* = VkFlags
VkCommandPoolCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkCommandPoolCreateFlags
queueFamilyIndex: uint32
VkCommandPool* = VkNonDispatchableHandle
PFN_vkCreateCommandPool* = proc (
device: VkDevice;
pCreateInfo: ptr VkCommandPoolCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pCommandPool: ptr VkCommandPool;
): VkResult {.cdecl.}
PFN_vkDestroyCommandPool* = proc (
device: VkDevice;
commandPool: VkCommandPool;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkCommandPoolResetFlags* = VkFlags
PFN_vkResetCommandPool* = proc (
device: VkDevice;
commandPool: VkCommandPool;
flags: VkCommandPoolResetFlags;
): VkResult {.cdecl.}
VkCommandBufferLevel* {.size: sizeof(cint).} = enum
VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0
VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
VkCommandBufferAllocateInfo* = object
sType: VkStructureType
pNext: pointer
commandPool: VkCommandPool
level: VkCommandBufferLevel
commandBufferCount: uint32
PFN_vkAllocateCommandBuffers* = proc (
device: VkDevice;
pAllocateInfo: ptr VkCommandBufferAllocateInfo;
pCommandBuffers: ptr VkCommandBuffer;
): VkResult {.cdecl.}
PFN_vkFreeCommandBuffers* = proc (
device: VkDevice;
commandPool: VkCommandPool;
commandBufferCount: uint32;
pCommandBuffers: ptr VkCommandBuffer;
): void {.cdecl.}
VkCommandBufferUsageFlags* = VkFlags
VkQueryControlFlags* = VkFlags
VkCommandBufferInheritanceInfo* = object
sType: VkStructureType
pNext: pointer
renderPass: VkRenderPass
subpass: uint32
framebuffer: VkFramebuffer
occlusionQueryEnable: VkBool32
queryFlags: VkQueryControlFlags
pipelineStatistics: VkQueryPipelineStatisticFlags
VkCommandBufferBeginInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkCommandBufferUsageFlags
pInheritanceInfo: ptr VkCommandBufferInheritanceInfo
PFN_vkBeginCommandBuffer* = proc (
commandBuffer: VkCommandBuffer;
pBeginInfo: ptr VkCommandBufferBeginInfo;
): VkResult {.cdecl.}
PFN_vkEndCommandBuffer* = proc (
commandBuffer: VkCommandBuffer;
): VkResult {.cdecl.}
VkCommandBufferResetFlags* = VkFlags
PFN_vkResetCommandBuffer* = proc (
commandBuffer: VkCommandBuffer;
flags: VkCommandBufferResetFlags;
): VkResult {.cdecl.}
PFN_vkCmdBindPipeline* = proc (
commandBuffer: VkCommandBuffer;
pipelineBindPoint: VkPipelineBindPoint;
pipeline: VkPipeline;
): void {.cdecl.}
PFN_vkCmdSetViewport* = proc (
commandBuffer: VkCommandBuffer;
firstViewport: uint32;
viewportCount: uint32;
pViewports: ptr VkViewport;
): void {.cdecl.}
PFN_vkCmdSetScissor* = proc (
commandBuffer: VkCommandBuffer;
firstScissor: uint32;
scissorCount: uint32;
pScissors: ptr VkRect2D;
): void {.cdecl.}
PFN_vkCmdSetLineWidth* = proc (
commandBuffer: VkCommandBuffer;
lineWidth: cfloat;
): void {.cdecl.}
PFN_vkCmdSetDepthBias* = proc (
commandBuffer: VkCommandBuffer;
depthBiasConstantFactor: cfloat;
depthBiasClamp: cfloat;
depthBiasSlopeFactor: cfloat;
): void {.cdecl.}
PFN_vkCmdSetBlendConstants* = proc (
commandBuffer: VkCommandBuffer;
blendConstants: array[4, cfloat];
): void {.cdecl.}
PFN_vkCmdSetDepthBounds* = proc (
commandBuffer: VkCommandBuffer;
minDepthBounds: cfloat;
maxDepthBounds: cfloat;
): void {.cdecl.}
VkStencilFaceFlags* = VkFlags
PFN_vkCmdSetStencilCompareMask* = proc (
commandBuffer: VkCommandBuffer;
faceMask: VkStencilFaceFlags;
compareMask: uint32;
): void {.cdecl.}
PFN_vkCmdSetStencilWriteMask* = proc (
commandBuffer: VkCommandBuffer;
faceMask: VkStencilFaceFlags;
writeMask: uint32;
): void {.cdecl.}
PFN_vkCmdSetStencilReference* = proc (
commandBuffer: VkCommandBuffer;
faceMask: VkStencilFaceFlags;
reference: uint32;
): void {.cdecl.}
PFN_vkCmdBindDescriptorSets* = proc (
commandBuffer: VkCommandBuffer;
pipelineBindPoint: VkPipelineBindPoint;
layout: VkPipelineLayout;
firstSet: uint32;
descriptorSetCount: uint32;
pDescriptorSets: ptr VkDescriptorSet;
dynamicOffsetCount: uint32;
pDynamicOffsets: ptr uint32;
): void {.cdecl.}
VkIndexType* {.size: sizeof(cint).} = enum
VK_INDEX_TYPE_UINT16 = 0
VK_INDEX_TYPE_UINT32 = 1
PFN_vkCmdBindIndexBuffer* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
indexType: VkIndexType;
): void {.cdecl.}
PFN_vkCmdBindVertexBuffers* = proc (
commandBuffer: VkCommandBuffer;
firstBinding: uint32;
bindingCount: uint32;
pBuffers: ptr VkBuffer;
pOffsets: ptr VkDeviceSize;
): void {.cdecl.}
PFN_vkCmdDraw* = proc (
commandBuffer: VkCommandBuffer;
vertexCount: uint32;
instanceCount: uint32;
firstVertex: uint32;
firstInstance: uint32;
): void {.cdecl.}
PFN_vkCmdDrawIndexed* = proc (
commandBuffer: VkCommandBuffer;
indexCount: uint32;
instanceCount: uint32;
firstIndex: uint32;
vertexOffset: int32;
firstInstance: uint32;
): void {.cdecl.}
PFN_vkCmdDrawIndirect* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
drawCount: uint32;
stride: uint32;
): void {.cdecl.}
PFN_vkCmdDrawIndexedIndirect* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
drawCount: uint32;
stride: uint32;
): void {.cdecl.}
PFN_vkCmdDispatch* = proc (
commandBuffer: VkCommandBuffer;
groupCountX: uint32;
groupCountY: uint32;
groupCountZ: uint32;
): void {.cdecl.}
PFN_vkCmdDispatchIndirect* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
): void {.cdecl.}
VkBufferCopy* = object
srcOffset: VkDeviceSize
dstOffset: VkDeviceSize
size: VkDeviceSize
PFN_vkCmdCopyBuffer* = proc (
commandBuffer: VkCommandBuffer;
srcBuffer: VkBuffer;
dstBuffer: VkBuffer;
regionCount: uint32;
pRegions: ptr VkBufferCopy;
): void {.cdecl.}
VkImageSubresourceLayers* = object
aspectMask: VkImageAspectFlags
mipLevel: uint32
baseArrayLayer: uint32
layerCount: uint32
VkImageCopy* = object
srcSubresource: VkImageSubresourceLayers
srcOffset: VkOffset3D
dstSubresource: VkImageSubresourceLayers
dstOffset: VkOffset3D
extent: VkExtent3D
PFN_vkCmdCopyImage* = proc (
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkImageCopy;
): void {.cdecl.}
VkImageBlit* = object
srcSubresource: VkImageSubresourceLayers
srcOffsets: array[2, VkOffset3D]
dstSubresource: VkImageSubresourceLayers
dstOffsets: array[2, VkOffset3D]
PFN_vkCmdBlitImage* = proc (
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkImageBlit;
filter: VkFilter;
): void {.cdecl.}
VkBufferImageCopy* = object
bufferOffset: VkDeviceSize
bufferRowLength: uint32
bufferImageHeight: uint32
imageSubresource: VkImageSubresourceLayers
imageOffset: VkOffset3D
imageExtent: VkExtent3D
PFN_vkCmdCopyBufferToImage* = proc (
commandBuffer: VkCommandBuffer;
srcBuffer: VkBuffer;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkBufferImageCopy;
): void {.cdecl.}
PFN_vkCmdCopyImageToBuffer* = proc (
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstBuffer: VkBuffer;
regionCount: uint32;
pRegions: ptr VkBufferImageCopy;
): void {.cdecl.}
PFN_vkCmdUpdateBuffer* = proc (
commandBuffer: VkCommandBuffer;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
dataSize: VkDeviceSize;
pData: pointer;
): void {.cdecl.}
PFN_vkCmdFillBuffer* = proc (
commandBuffer: VkCommandBuffer;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
size: VkDeviceSize;
data: uint32;
): void {.cdecl.}
VkClearColorValue* = object
float32: array[4, cfloat]
int32: array[4, int32]
uint32: array[4, uint32]
PFN_vkCmdClearColorImage* = proc (
commandBuffer: VkCommandBuffer;
image: VkImage;
imageLayout: VkImageLayout;
pColor: ptr VkClearColorValue;
rangeCount: uint32;
pRanges: ptr VkImageSubresourceRange;
): void {.cdecl.}
VkClearDepthStencilValue* = object
depth: cfloat
stencil: uint32
PFN_vkCmdClearDepthStencilImage* = proc (
commandBuffer: VkCommandBuffer;
image: VkImage;
imageLayout: VkImageLayout;
pDepthStencil: ptr VkClearDepthStencilValue;
rangeCount: uint32;
pRanges: ptr VkImageSubresourceRange;
): void {.cdecl.}
VkClearValue* = object
color: VkClearColorValue
depthStencil: VkClearDepthStencilValue
VkClearAttachment* = object
aspectMask: VkImageAspectFlags
colorAttachment: uint32
clearValue: VkClearValue
VkClearRect* = object
rect: VkRect2D
baseArrayLayer: uint32
layerCount: uint32
PFN_vkCmdClearAttachments* = proc (
commandBuffer: VkCommandBuffer;
attachmentCount: uint32;
pAttachments: ptr VkClearAttachment;
rectCount: uint32;
pRects: ptr VkClearRect;
): void {.cdecl.}
VkImageResolve* = object
srcSubresource: VkImageSubresourceLayers
srcOffset: VkOffset3D
dstSubresource: VkImageSubresourceLayers
dstOffset: VkOffset3D
extent: VkExtent3D
PFN_vkCmdResolveImage* = proc (
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkImageResolve;
): void {.cdecl.}
PFN_vkCmdSetEvent* = proc (
commandBuffer: VkCommandBuffer;
event: VkEvent;
stageMask: VkPipelineStageFlags;
): void {.cdecl.}
PFN_vkCmdResetEvent* = proc (
commandBuffer: VkCommandBuffer;
event: VkEvent;
stageMask: VkPipelineStageFlags;
): void {.cdecl.}
VkMemoryBarrier* = object
sType: VkStructureType
pNext: pointer
srcAccessMask: VkAccessFlags
dstAccessMask: VkAccessFlags
VkBufferMemoryBarrier* = object
sType: VkStructureType
pNext: pointer
srcAccessMask: VkAccessFlags
dstAccessMask: VkAccessFlags
srcQueueFamilyIndex: uint32
dstQueueFamilyIndex: uint32
buffer: VkBuffer
offset: VkDeviceSize
size: VkDeviceSize
VkImageMemoryBarrier* = object
sType: VkStructureType
pNext: pointer
srcAccessMask: VkAccessFlags
dstAccessMask: VkAccessFlags
oldLayout: VkImageLayout
newLayout: VkImageLayout
srcQueueFamilyIndex: uint32
dstQueueFamilyIndex: uint32
image: VkImage
subresourceRange: VkImageSubresourceRange
PFN_vkCmdWaitEvents* = proc (
commandBuffer: VkCommandBuffer;
eventCount: uint32;
pEvents: ptr VkEvent;
srcStageMask: VkPipelineStageFlags;
dstStageMask: VkPipelineStageFlags;
memoryBarrierCount: uint32;
pMemoryBarriers: ptr VkMemoryBarrier;
bufferMemoryBarrierCount: uint32;
pBufferMemoryBarriers: ptr VkBufferMemoryBarrier;
imageMemoryBarrierCount: uint32;
pImageMemoryBarriers: ptr VkImageMemoryBarrier;
): void {.cdecl.}
PFN_vkCmdPipelineBarrier* = proc (
commandBuffer: VkCommandBuffer;
srcStageMask: VkPipelineStageFlags;
dstStageMask: VkPipelineStageFlags;
dependencyFlags: VkDependencyFlags;
memoryBarrierCount: uint32;
pMemoryBarriers: ptr VkMemoryBarrier;
bufferMemoryBarrierCount: uint32;
pBufferMemoryBarriers: ptr VkBufferMemoryBarrier;
imageMemoryBarrierCount: uint32;
pImageMemoryBarriers: ptr VkImageMemoryBarrier;
): void {.cdecl.}
PFN_vkCmdBeginQuery* = proc (
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
query: uint32;
flags: VkQueryControlFlags;
): void {.cdecl.}
PFN_vkCmdEndQuery* = proc (
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
query: uint32;
): void {.cdecl.}
PFN_vkCmdResetQueryPool* = proc (
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
firstQuery: uint32;
queryCount: uint32;
): void {.cdecl.}
VkPipelineStageFlagBits* {.size: sizeof(cint).} = enum
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800
VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000
VK_PIPELINE_STAGE_HOST_BIT = 0x00004000
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000
VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000
VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000
VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000
VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000
VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX = 0x00200000
VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000
VK_PIPELINE_STAGE_RESERVED_23_BIT_EXT = 0x00800000
PFN_vkCmdWriteTimestamp* = proc (
commandBuffer: VkCommandBuffer;
pipelineStage: VkPipelineStageFlagBits;
queryPool: VkQueryPool;
query: uint32;
): void {.cdecl.}
PFN_vkCmdCopyQueryPoolResults* = proc (
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
firstQuery: uint32;
queryCount: uint32;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
stride: VkDeviceSize;
flags: VkQueryResultFlags;
): void {.cdecl.}
PFN_vkCmdPushConstants* = proc (
commandBuffer: VkCommandBuffer;
layout: VkPipelineLayout;
stageFlags: VkShaderStageFlags;
offset: uint32;
size: uint32;
pValues: pointer;
): void {.cdecl.}
VkRenderPassBeginInfo* = object
sType: VkStructureType
pNext: pointer
renderPass: VkRenderPass
framebuffer: VkFramebuffer
renderArea: VkRect2D
clearValueCount: uint32
pClearValues: ptr VkClearValue
VkSubpassContents* {.size: sizeof(cint).} = enum
VK_SUBPASS_CONTENTS_INLINE = 0
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
PFN_vkCmdBeginRenderPass* = proc (
commandBuffer: VkCommandBuffer;
pRenderPassBegin: ptr VkRenderPassBeginInfo;
contents: VkSubpassContents;
): void {.cdecl.}
PFN_vkCmdNextSubpass* = proc (
commandBuffer: VkCommandBuffer;
contents: VkSubpassContents;
): void {.cdecl.}
PFN_vkCmdEndRenderPass* = proc (
commandBuffer: VkCommandBuffer;
): void {.cdecl.}
PFN_vkCmdExecuteCommands* = proc (
commandBuffer: VkCommandBuffer;
commandBufferCount: uint32;
pCommandBuffers: ptr VkCommandBuffer;
): void {.cdecl.}
VkDispatchIndirectCommand* = object
x: uint32
y: uint32
z: uint32
VkDrawIndexedIndirectCommand* = object
indexCount: uint32
instanceCount: uint32
firstIndex: uint32
vertexOffset: int32
firstInstance: uint32
VkDrawIndirectCommand* = object
vertexCount: uint32
instanceCount: uint32
firstVertex: uint32
firstInstance: uint32
VkObjectType* {.size: sizeof(cint).} = enum
VK_OBJECT_TYPE_UNKNOWN = 0
VK_OBJECT_TYPE_INSTANCE = 1
VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2
VK_OBJECT_TYPE_DEVICE = 3
VK_OBJECT_TYPE_QUEUE = 4
VK_OBJECT_TYPE_SEMAPHORE = 5
VK_OBJECT_TYPE_COMMAND_BUFFER = 6
VK_OBJECT_TYPE_FENCE = 7
VK_OBJECT_TYPE_DEVICE_MEMORY = 8
VK_OBJECT_TYPE_BUFFER = 9
VK_OBJECT_TYPE_IMAGE = 10
VK_OBJECT_TYPE_EVENT = 11
VK_OBJECT_TYPE_QUERY_POOL = 12
VK_OBJECT_TYPE_BUFFER_VIEW = 13
VK_OBJECT_TYPE_IMAGE_VIEW = 14
VK_OBJECT_TYPE_SHADER_MODULE = 15
VK_OBJECT_TYPE_PIPELINE_CACHE = 16
VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17
VK_OBJECT_TYPE_RENDER_PASS = 18
VK_OBJECT_TYPE_PIPELINE = 19
VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20
VK_OBJECT_TYPE_SAMPLER = 21
VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22
VK_OBJECT_TYPE_DESCRIPTOR_SET = 23
VK_OBJECT_TYPE_FRAMEBUFFER = 24
VK_OBJECT_TYPE_COMMAND_POOL = 25
VK_OBJECT_TYPE_SURFACE_KHR = 1000000000
VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000
VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000
VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001
VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000
VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000
VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001
VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000
VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000
VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000
VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX = 1000165000
VkBaseOutStructure* = object
sType: VkStructureType
pNext: ptr VkBaseOutStructure
VkBaseInStructure* = object
sType: VkStructureType
pNext: ptr VkBaseInStructure
VkVendorId* {.size: sizeof(cint).} = enum
VK_VENDOR_ID_VIV = 0x10001
VK_VENDOR_ID_VSI = 0x10002
VK_VENDOR_ID_KAZAN = 0x10003
const
vkVersion11* = vkMakeVersion(1, 1, 0)
type
PFN_vkEnumerateInstanceVersion* = proc (
pApiVersion: ptr uint32;
): VkResult {.cdecl.}
VkSubgroupFeatureFlags* = VkFlags
VkPhysicalDeviceSubgroupProperties* = object
sType: VkStructureType
pNext: pointer
subgroupSize: uint32
supportedStages: VkShaderStageFlags
supportedOperations: VkSubgroupFeatureFlags
quadOperationsInAllStages: VkBool32
VkSubgroupFeatureFlagBits* {.size: sizeof(cint).} = enum
VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001
VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002
VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004
VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008
VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010
VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020
VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040
VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100
VkBindBufferMemoryInfo* = object
sType: VkStructureType
pNext: pointer
buffer: VkBuffer
memory: VkDeviceMemory
memoryOffset: VkDeviceSize
PFN_vkBindBufferMemory2* = proc (
device: VkDevice;
bindInfoCount: uint32;
pBindInfos: ptr VkBindBufferMemoryInfo;
): VkResult {.cdecl.}
VkBindImageMemoryInfo* = object
sType: VkStructureType
pNext: pointer
image: VkImage
memory: VkDeviceMemory
memoryOffset: VkDeviceSize
PFN_vkBindImageMemory2* = proc (
device: VkDevice;
bindInfoCount: uint32;
pBindInfos: ptr VkBindImageMemoryInfo;
): VkResult {.cdecl.}
VkImageCreateFlagBits* {.size: sizeof(cint).} = enum
VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100
VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200
VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400
VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800
VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000
VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000
VK_IMAGE_CREATE_RESERVED_14_BIT_EXT = 0x00004000
VkPhysicalDevice16BitStorageFeatures* = object
sType: VkStructureType
pNext: pointer
storageBuffer16BitAccess: VkBool32
uniformAndStorageBuffer16BitAccess: VkBool32
storagePushConstant16: VkBool32
storageInputOutput16: VkBool32
VkMemoryDedicatedRequirements* = object
sType: VkStructureType
pNext: pointer
prefersDedicatedAllocation: VkBool32
requiresDedicatedAllocation: VkBool32
VkMemoryDedicatedAllocateInfo* = object
sType: VkStructureType
pNext: pointer
image: VkImage
buffer: VkBuffer
VkPeerMemoryFeatureFlags* = VkFlags
VkPeerMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum
VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001
VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002
VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004
VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008
VkMemoryAllocateFlags* = VkFlags
VkMemoryAllocateFlagBits* {.size: sizeof(cint).} = enum
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001
VkMemoryAllocateFlagsInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkMemoryAllocateFlags
deviceMask: uint32
VkDeviceGroupRenderPassBeginInfo* = object
sType: VkStructureType
pNext: pointer
deviceMask: uint32
deviceRenderAreaCount: uint32
pDeviceRenderAreas: ptr VkRect2D
VkDeviceGroupCommandBufferBeginInfo* = object
sType: VkStructureType
pNext: pointer
deviceMask: uint32
VkDeviceGroupSubmitInfo* = object
sType: VkStructureType
pNext: pointer
waitSemaphoreCount: uint32
pWaitSemaphoreDeviceIndices: ptr uint32
commandBufferCount: uint32
pCommandBufferDeviceMasks: ptr uint32
signalSemaphoreCount: uint32
pSignalSemaphoreDeviceIndices: ptr uint32
VkDeviceGroupBindSparseInfo* = object
sType: VkStructureType
pNext: pointer
resourceDeviceIndex: uint32
memoryDeviceIndex: uint32
PFN_vkGetDeviceGroupPeerMemoryFeatures* = proc (
device: VkDevice;
heapIndex: uint32;
localDeviceIndex: uint32;
remoteDeviceIndex: uint32;
pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags;
): void {.cdecl.}
PFN_vkCmdSetDeviceMask* = proc (
commandBuffer: VkCommandBuffer;
deviceMask: uint32;
): void {.cdecl.}
PFN_vkCmdDispatchBase* = proc (
commandBuffer: VkCommandBuffer;
baseGroupX: uint32;
baseGroupY: uint32;
baseGroupZ: uint32;
groupCountX: uint32;
groupCountY: uint32;
groupCountZ: uint32;
): void {.cdecl.}
VkPipelineCreateFlagBits* {.size: sizeof(cint).} = enum
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008
VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX = 0x00000020
VkDependencyFlagBits* {.size: sizeof(cint).} = enum
VK_DEPENDENCY_BY_REGION_BIT = 0x00000001
VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002
VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004
VkBindBufferMemoryDeviceGroupInfo* = object
sType: VkStructureType
pNext: pointer
deviceIndexCount: uint32
pDeviceIndices: ptr uint32
VkBindImageMemoryDeviceGroupInfo* = object
sType: VkStructureType
pNext: pointer
deviceIndexCount: uint32
pDeviceIndices: ptr uint32
splitInstanceBindRegionCount: uint32
pSplitInstanceBindRegions: ptr VkRect2D
const
VK_MAX_DEVICE_GROUP_SIZE* = 32
type
VkPhysicalDeviceGroupProperties* = object
sType: VkStructureType
pNext: pointer
physicalDeviceCount: uint32
physicalDevices: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice]
subsetAllocation: VkBool32
VkDeviceGroupDeviceCreateInfo* = object
sType: VkStructureType
pNext: pointer
physicalDeviceCount: uint32
pPhysicalDevices: ptr VkPhysicalDevice
PFN_vkEnumeratePhysicalDeviceGroups* = proc (
instance: VkInstance;
pPhysicalDeviceGroupCount: ptr uint32;
pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties;
): VkResult {.cdecl.}
VkMemoryHeapFlagBits* {.size: sizeof(cint).} = enum
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002
VkBufferMemoryRequirementsInfo2* = object
sType: VkStructureType
pNext: pointer
buffer: VkBuffer
VkImageMemoryRequirementsInfo2* = object
sType: VkStructureType
pNext: pointer
image: VkImage
VkImageSparseMemoryRequirementsInfo2* = object
sType: VkStructureType
pNext: pointer
image: VkImage
VkMemoryRequirements2* = object
sType: VkStructureType
pNext: pointer
memoryRequirements: VkMemoryRequirements
VkMemoryRequirements2KHR* = VkMemoryRequirements2
VkSparseImageMemoryRequirements2* = object
sType: VkStructureType
pNext: pointer
memoryRequirements: VkSparseImageMemoryRequirements
PFN_vkGetImageMemoryRequirements2* = proc (
device: VkDevice;
pInfo: ptr VkImageMemoryRequirementsInfo2;
pMemoryRequirements: ptr VkMemoryRequirements2;
): void {.cdecl.}
PFN_vkGetBufferMemoryRequirements2* = proc (
device: VkDevice;
pInfo: ptr VkBufferMemoryRequirementsInfo2;
pMemoryRequirements: ptr VkMemoryRequirements2;
): void {.cdecl.}
PFN_vkGetImageSparseMemoryRequirements2* = proc (
device: VkDevice;
pInfo: ptr VkImageSparseMemoryRequirementsInfo2;
pSparseMemoryRequirementCount: ptr uint32;
pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2;
): void {.cdecl.}
VkPhysicalDeviceFeatures2* = object
sType: VkStructureType
pNext: pointer
features: VkPhysicalDeviceFeatures
VkPhysicalDeviceProperties2* = object
sType: VkStructureType
pNext: pointer
properties: VkPhysicalDeviceProperties
VkFormatProperties2* = object
sType: VkStructureType
pNext: pointer
formatProperties: VkFormatProperties
VkImageFormatProperties2* = object
sType: VkStructureType
pNext: pointer
imageFormatProperties: VkImageFormatProperties
VkPhysicalDeviceImageFormatInfo2* = object
sType: VkStructureType
pNext: pointer
format: VkFormat
theType: VkImageType
tiling: VkImageTiling
usage: VkImageUsageFlags
flags: VkImageCreateFlags
VkQueueFamilyProperties2* = object
sType: VkStructureType
pNext: pointer
queueFamilyProperties: VkQueueFamilyProperties
VkPhysicalDeviceMemoryProperties2* = object
sType: VkStructureType
pNext: pointer
memoryProperties: VkPhysicalDeviceMemoryProperties
VkSparseImageFormatProperties2* = object
sType: VkStructureType
pNext: pointer
properties: VkSparseImageFormatProperties
VkPhysicalDeviceSparseImageFormatInfo2* = object
sType: VkStructureType
pNext: pointer
format: VkFormat
theType: VkImageType
samples: VkSampleCountFlagBits
usage: VkImageUsageFlags
tiling: VkImageTiling
PFN_vkGetPhysicalDeviceFeatures2* = proc (
physicalDevice: VkPhysicalDevice;
pFeatures: ptr VkPhysicalDeviceFeatures2;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceProperties2* = proc (
physicalDevice: VkPhysicalDevice;
pProperties: ptr VkPhysicalDeviceProperties2;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceFormatProperties2* = proc (
physicalDevice: VkPhysicalDevice;
format: VkFormat;
pFormatProperties: ptr VkFormatProperties2;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceImageFormatProperties2* = proc (
physicalDevice: VkPhysicalDevice;
pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2;
pImageFormatProperties: ptr VkImageFormatProperties2;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDeviceQueueFamilyProperties2* = proc (
physicalDevice: VkPhysicalDevice;
pQueueFamilyPropertyCount: ptr uint32;
pQueueFamilyProperties: ptr VkQueueFamilyProperties2;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceMemoryProperties2* = proc (
physicalDevice: VkPhysicalDevice;
pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2* = proc (
physicalDevice: VkPhysicalDevice;
pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2;
pPropertyCount: ptr uint32;
pProperties: ptr VkSparseImageFormatProperties2;
): void {.cdecl.}
VkFormatFeatureFlagBits* {.size: sizeof(cint).} = enum
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004
VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200
VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400
VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000
VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000
VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000
VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000
VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000
VK_FORMAT_FEATURE_RESERVED_24_BIT_EXT = 0x01000000
VkCommandPoolTrimFlags* = VkFlags
PFN_vkTrimCommandPool* = proc (
device: VkDevice;
commandPool: VkCommandPool;
flags: VkCommandPoolTrimFlags;
): void {.cdecl.}
VkPointClippingBehavior* {.size: sizeof(cint).} = enum
VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0
VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1
VkPhysicalDevicePointClippingProperties* = object
sType: VkStructureType
pNext: pointer
pointClippingBehavior: VkPointClippingBehavior
VkInputAttachmentAspectReference* = object
subpass: uint32
inputAttachmentIndex: uint32
aspectMask: VkImageAspectFlags
VkRenderPassInputAttachmentAspectCreateInfo* = object
sType: VkStructureType
pNext: pointer
aspectReferenceCount: uint32
pAspectReferences: ptr VkInputAttachmentAspectReference
VkImageViewUsageCreateInfo* = object
sType: VkStructureType
pNext: pointer
usage: VkImageUsageFlags
VkTessellationDomainOrigin* {.size: sizeof(cint).} = enum
VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0
VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1
VkPipelineTessellationDomainOriginStateCreateInfo* = object
sType: VkStructureType
pNext: pointer
domainOrigin: VkTessellationDomainOrigin
VkRenderPassMultiviewCreateInfo* = object
sType: VkStructureType
pNext: pointer
subpassCount: uint32
pViewMasks: ptr uint32
dependencyCount: uint32
pViewOffsets: ptr int32
correlationMaskCount: uint32
pCorrelationMasks: ptr uint32
VkPhysicalDeviceMultiviewFeatures* = object
sType: VkStructureType
pNext: pointer
multiview: VkBool32
multiviewGeometryShader: VkBool32
multiviewTessellationShader: VkBool32
VkPhysicalDeviceMultiviewProperties* = object
sType: VkStructureType
pNext: pointer
maxMultiviewViewCount: uint32
maxMultiviewInstanceIndex: uint32
VkPhysicalDeviceVariablePointerFeatures* = object
sType: VkStructureType
pNext: pointer
variablePointersStorageBuffer: VkBool32
variablePointers: VkBool32
VkQueueFlagBits* {.size: sizeof(cint).} = enum
VK_QUEUE_GRAPHICS_BIT = 0x00000001
VK_QUEUE_COMPUTE_BIT = 0x00000002
VK_QUEUE_TRANSFER_BIT = 0x00000004
VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008
VK_QUEUE_PROTECTED_BIT = 0x00000010
VkDeviceQueueCreateFlagBits* {.size: sizeof(cint).} = enum
VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001
VkMemoryPropertyFlagBits* {.size: sizeof(cint).} = enum
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004
VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010
VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020
VkBufferCreateFlagBits* {.size: sizeof(cint).} = enum
VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004
VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008
VkCommandPoolCreateFlagBits* {.size: sizeof(cint).} = enum
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002
VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004
VkPhysicalDeviceProtectedMemoryFeatures* = object
sType: VkStructureType
pNext: pointer
protectedMemory: VkBool32
VkPhysicalDeviceProtectedMemoryProperties* = object
sType: VkStructureType
pNext: pointer
protectedNoFault: VkBool32
VkDeviceQueueInfo2* = object
sType: VkStructureType
pNext: pointer
flags: VkDeviceQueueCreateFlags
queueFamilyIndex: uint32
queueIndex: uint32
VkProtectedSubmitInfo* = object
sType: VkStructureType
pNext: pointer
protectedSubmit: VkBool32
PFN_vkGetDeviceQueue2* = proc (
device: VkDevice;
pQueueInfo: ptr VkDeviceQueueInfo2;
pQueue: ptr VkQueue;
): void {.cdecl.}
VkImageAspectFlagBits* {.size: sizeof(cint).} = enum
VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001
VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002
VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004
VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008
VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010
VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020
VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040
VkSamplerYcbcrModelConversion* {.size: sizeof(cint).} = enum
VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4
VkSamplerYcbcrRange* {.size: sizeof(cint).} = enum
VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0
VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1
VkChromaLocation* {.size: sizeof(cint).} = enum
VK_CHROMA_LOCATION_COSITED_EVEN = 0
VK_CHROMA_LOCATION_MIDPOINT = 1
VkSamplerYcbcrConversionCreateInfo* = object
sType: VkStructureType
pNext: pointer
format: VkFormat
ycbcrModel: VkSamplerYcbcrModelConversion
ycbcrRange: VkSamplerYcbcrRange
components: VkComponentMapping
xChromaOffset: VkChromaLocation
yChromaOffset: VkChromaLocation
chromaFilter: VkFilter
forceExplicitReconstruction: VkBool32
VkSamplerYcbcrConversion* = VkNonDispatchableHandle
VkSamplerYcbcrConversionInfo* = object
sType: VkStructureType
pNext: pointer
conversion: VkSamplerYcbcrConversion
VkBindImagePlaneMemoryInfo* = object
sType: VkStructureType
pNext: pointer
planeAspect: VkImageAspectFlagBits
VkImagePlaneMemoryRequirementsInfo* = object
sType: VkStructureType
pNext: pointer
planeAspect: VkImageAspectFlagBits
VkPhysicalDeviceSamplerYcbcrConversionFeatures* = object
sType: VkStructureType
pNext: pointer
samplerYcbcrConversion: VkBool32
VkSamplerYcbcrConversionImageFormatProperties* = object
sType: VkStructureType
pNext: pointer
combinedImageSamplerDescriptorCount: uint32
PFN_vkCreateSamplerYcbcrConversion* = proc (
device: VkDevice;
pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pYcbcrConversion: ptr VkSamplerYcbcrConversion;
): VkResult {.cdecl.}
PFN_vkDestroySamplerYcbcrConversion* = proc (
device: VkDevice;
ycbcrConversion: VkSamplerYcbcrConversion;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
VkDescriptorUpdateTemplateCreateFlags* = VkFlags
VkDescriptorUpdateTemplateEntry* = object
dstBinding: uint32
dstArrayElement: uint32
descriptorCount: uint32
descriptorType: VkDescriptorType
offset: csize
stride: csize
VkDescriptorUpdateTemplateType* {.size: sizeof(cint).} = enum
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1
VkDescriptorUpdateTemplateCreateInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkDescriptorUpdateTemplateCreateFlags
descriptorUpdateEntryCount: uint32
pDescriptorUpdateEntries: ptr VkDescriptorUpdateTemplateEntry
templateType: VkDescriptorUpdateTemplateType
descriptorSetLayout: VkDescriptorSetLayout
pipelineBindPoint: VkPipelineBindPoint
pipelineLayout: VkPipelineLayout
set: uint32
VkDescriptorUpdateTemplate* = VkNonDispatchableHandle
PFN_vkCreateDescriptorUpdateTemplate* = proc (
device: VkDevice;
pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate;
): VkResult {.cdecl.}
PFN_vkDestroyDescriptorUpdateTemplate* = proc (
device: VkDevice;
descriptorUpdateTemplate: VkDescriptorUpdateTemplate;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkUpdateDescriptorSetWithTemplate* = proc (
device: VkDevice;
descriptorSet: VkDescriptorSet;
descriptorUpdateTemplate: VkDescriptorUpdateTemplate;
pData: pointer;
): void {.cdecl.}
const
VK_LUID_SIZE* = 8
type
VkExternalMemoryHandleTypeFlags* = VkFlags
VkExternalMemoryHandleTypeFlagBits* {.size: sizeof(cint).} = enum
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040
VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080
VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200
VkExternalMemoryFeatureFlags* = VkFlags
VkExternalMemoryFeatureFlagBits* {.size: sizeof(cint).} = enum
VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001
VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004
VkExternalMemoryProperties* = object
externalMemoryFeatures: VkExternalMemoryFeatureFlags
exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags
compatibleHandleTypes: VkExternalMemoryHandleTypeFlags
VkPhysicalDeviceExternalImageFormatInfo* = object
sType: VkStructureType
pNext: pointer
handleType: VkExternalMemoryHandleTypeFlagBits
VkExternalImageFormatProperties* = object
sType: VkStructureType
pNext: pointer
externalMemoryProperties: VkExternalMemoryProperties
VkPhysicalDeviceExternalBufferInfo* = object
sType: VkStructureType
pNext: pointer
flags: VkBufferCreateFlags
usage: VkBufferUsageFlags
handleType: VkExternalMemoryHandleTypeFlagBits
VkExternalBufferProperties* = object
sType: VkStructureType
pNext: pointer
externalMemoryProperties: VkExternalMemoryProperties
VkPhysicalDeviceIDProperties* = object
sType: VkStructureType
pNext: pointer
deviceUUID: array[VK_UUID_SIZE, uint8]
driverUUID: array[VK_UUID_SIZE, uint8]
deviceLUID: array[VK_LUID_SIZE, uint8]
deviceNodeMask: uint32
deviceLUIDValid: VkBool32
PFN_vkGetPhysicalDeviceExternalBufferProperties* = proc (
physicalDevice: VkPhysicalDevice;
pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo;
pExternalBufferProperties: ptr VkExternalBufferProperties;
): void {.cdecl.}
const
VK_QUEUE_FAMILY_EXTERNAL* = (not 0'u - 1)
type
VkExternalMemoryImageCreateInfo* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalMemoryHandleTypeFlags
VkExternalMemoryBufferCreateInfo* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalMemoryHandleTypeFlags
VkExportMemoryAllocateInfo* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalMemoryHandleTypeFlags
VkExternalFenceHandleTypeFlags* = VkFlags
VkExternalFenceHandleTypeFlagBits* {.size: sizeof(cint).} = enum
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004
VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008
VkExternalFenceFeatureFlags* = VkFlags
VkExternalFenceFeatureFlagBits* {.size: sizeof(cint).} = enum
VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001
VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002
VkPhysicalDeviceExternalFenceInfo* = object
sType: VkStructureType
pNext: pointer
handleType: VkExternalFenceHandleTypeFlagBits
VkExternalFenceProperties* = object
sType: VkStructureType
pNext: pointer
exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags
compatibleHandleTypes: VkExternalFenceHandleTypeFlags
externalFenceFeatures: VkExternalFenceFeatureFlags
PFN_vkGetPhysicalDeviceExternalFenceProperties* = proc (
physicalDevice: VkPhysicalDevice;
pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo;
pExternalFenceProperties: ptr VkExternalFenceProperties;
): void {.cdecl.}
VkFenceImportFlags* = VkFlags
VkFenceImportFlagBits* {.size: sizeof(cint).} = enum
VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001
VkExportFenceCreateInfo* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalFenceHandleTypeFlags
VkSemaphoreImportFlags* = VkFlags
VkSemaphoreImportFlagBits* {.size: sizeof(cint).} = enum
VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001
VkExternalSemaphoreHandleTypeFlags* = VkFlags
VkExportSemaphoreCreateInfo* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalSemaphoreHandleTypeFlags
VkExternalSemaphoreHandleTypeFlagBits* {.size: sizeof(cint).} = enum
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010
VkExternalSemaphoreFeatureFlags* = VkFlags
VkExternalSemaphoreFeatureFlagBits* {.size: sizeof(cint).} = enum
VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002
VkPhysicalDeviceExternalSemaphoreInfo* = object
sType: VkStructureType
pNext: pointer
handleType: VkExternalSemaphoreHandleTypeFlagBits
VkExternalSemaphoreProperties* = object
sType: VkStructureType
pNext: pointer
exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags
compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags
externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties* = proc (
physicalDevice: VkPhysicalDevice;
pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo;
pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties;
): void {.cdecl.}
VkPhysicalDeviceMaintenance3Properties* = object
sType: VkStructureType
pNext: pointer
maxPerSetDescriptors: uint32
maxMemoryAllocationSize: VkDeviceSize
VkDescriptorSetLayoutSupport* = object
sType: VkStructureType
pNext: pointer
supported: VkBool32
PFN_vkGetDescriptorSetLayoutSupport* = proc (
device: VkDevice;
pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo;
pSupport: ptr VkDescriptorSetLayoutSupport;
): void {.cdecl.}
VkPhysicalDeviceShaderDrawParameterFeatures* = object
sType: VkStructureType
pNext: pointer
shaderDrawParameters: VkBool32
const
VK_KHR_EXTENSION_184_SPEC_VERSION* = 0
VK_KHR_EXTENSION_184_EXTENSION_NAME* = "VK_AMD_extension_184"
VK_AMD_SHADER_BALLOT_SPEC_VERSION* = 1
VK_AMD_SHADER_BALLOT_EXTENSION_NAME* = "VK_AMD_shader_ballot"
VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION* = 1
VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME*
= "VK_NV_representative_fragment_test"
type
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* = object
sType: VkStructureType
pNext: pointer
representativeFragmentTest: VkBool32
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
representativeFragmentTestEnable: VkBool32
const
VK_NVX_EXTENSION_31_SPEC_VERSION* = 0
VK_NVX_EXTENSION_31_EXTENSION_NAME* = "VK_NVX_extension_31"
VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION* = 1
VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME* = "VK_EXT_astc_decode_mode"
type
VkImageViewASTCDecodeModeEXT* = object
sType: VkStructureType
pNext: pointer
decodeMode: VkFormat
VkPhysicalDeviceASTCDecodeFeaturesEXT* = object
sType: VkStructureType
pNext: pointer
decodeModeSharedExponent: VkBool32
const
VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION* = 1
VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME*
= "VK_KHR_storage_buffer_storage_class"
VK_QCOM_extension_172_SPEC_VERSION* = 0
VK_QCOM_extension_172_EXTENSION_NAME* = "VK_QCOM_extension_172"
VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION* = 1
VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME* = "VK_EXT_queue_family_foreign"
VK_QUEUE_FAMILY_FOREIGN_EXT* = (not 0'u - 2)
VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME*
= "VK_KHR_external_semaphore_fd"
type
VkImportSemaphoreFdInfoKHR* = object
sType: VkStructureType
pNext: pointer
semaphore: VkSemaphore
flags: VkSemaphoreImportFlags
handleType: VkExternalSemaphoreHandleTypeFlagBits
fd: int
VkSemaphoreGetFdInfoKHR* = object
sType: VkStructureType
pNext: pointer
semaphore: VkSemaphore
handleType: VkExternalSemaphoreHandleTypeFlagBits
PFN_vkImportSemaphoreFdKHR* = proc (
device: VkDevice;
pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR;
): VkResult {.cdecl.}
PFN_vkGetSemaphoreFdKHR* = proc (
device: VkDevice;
pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR;
pFd: ptr int;
): VkResult {.cdecl.}
const
VK_KHR_EXTENSION_201_SPEC_VERSION* = 0
VK_KHR_EXTENSION_201_EXTENSION_NAME* = "VK_KHR_extension_201"
VK_AMD_GPU_SHADER_INT16_SPEC_VERSION* = 1
VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME* = "VK_AMD_gpu_shader_int16"
VK_EXT_EXTENSION_28_SPEC_VERSION* = 0
VK_EXT_EXTENSION_28_EXTENSION_NAME* = "VK_NV_extension_28"
VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION* = 1
VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME*
= "VK_AMD_shader_image_load_store_lod"
VK_EXT_EXTENSION_220_SPEC_VERSION* = 0
VK_EXT_EXTENSION_220_EXTENSION_NAME* = "VK_EXT_extension_220"
VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION* = 1
VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME*
= "VK_NV_shader_subgroup_partitioned"
VK_AMD_EXTENSION_25_SPEC_VERSION* = 0
VK_AMD_EXTENSION_25_EXTENSION_NAME* = "VK_AMD_extension_25"
VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION* = 1
VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME*
= "VK_AMD_texture_gather_bias_lod"
type
VkTextureLODGatherFormatPropertiesAMD* = object
sType: VkStructureType
pNext: pointer
supportsTextureGatherLODBiasAMD: VkBool32
const
VK_NV_EXTENSION_155_SPEC_VERSION* = 0
VK_NV_EXTENSION_155_EXTENSION_NAME* = "VK_NV_extension_155"
VK_KHR_SWAPCHAIN_SPEC_VERSION* = 70
VK_KHR_SWAPCHAIN_EXTENSION_NAME* = "VK_KHR_swapchain"
type
VkSwapchainCreateFlagsKHR* = VkFlags
VkSurfaceKHR* = VkNonDispatchableHandle
VkColorSpaceKHR* {.size: sizeof(cint).} = enum
VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0
VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001
VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002
VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003
VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004
VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005
VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006
VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007
VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008
VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009
VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010
VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011
VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012
VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013
VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014
VkSurfaceTransformFlagBitsKHR* {.size: sizeof(cint).} = enum
VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001
VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002
VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004
VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080
VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100
VkCompositeAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001
VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008
VkPresentModeKHR* {.size: sizeof(cint).} = enum
VK_PRESENT_MODE_IMMEDIATE_KHR = 0
VK_PRESENT_MODE_MAILBOX_KHR = 1
VK_PRESENT_MODE_FIFO_KHR = 2
VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3
VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000
VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001
VkSwapchainKHR* = VkNonDispatchableHandle
VkSwapchainCreateInfoKHR* = object
sType: VkStructureType
pNext: pointer
flags: VkSwapchainCreateFlagsKHR
surface: VkSurfaceKHR
minImageCount: uint32
imageFormat: VkFormat
imageColorSpace: VkColorSpaceKHR
imageExtent: VkExtent2D
imageArrayLayers: uint32
imageUsage: VkImageUsageFlags
imageSharingMode: VkSharingMode
queueFamilyIndexCount: uint32
pQueueFamilyIndices: ptr uint32
preTransform: VkSurfaceTransformFlagBitsKHR
compositeAlpha: VkCompositeAlphaFlagBitsKHR
presentMode: VkPresentModeKHR
clipped: VkBool32
oldSwapchain: VkSwapchainKHR
PFN_vkCreateSwapchainKHR* = proc (
device: VkDevice;
pCreateInfo: ptr VkSwapchainCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pSwapchain: ptr VkSwapchainKHR;
): VkResult {.cdecl.}
PFN_vkDestroySwapchainKHR* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkGetSwapchainImagesKHR* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
pSwapchainImageCount: ptr uint32;
pSwapchainImages: ptr VkImage;
): VkResult {.cdecl.}
PFN_vkAcquireNextImageKHR* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
timeout: uint64;
semaphore: VkSemaphore;
fence: VkFence;
pImageIndex: ptr uint32;
): VkResult {.cdecl.}
VkPresentInfoKHR* = object
sType: VkStructureType
pNext: pointer
waitSemaphoreCount: uint32
pWaitSemaphores: ptr VkSemaphore
swapchainCount: uint32
pSwapchains: ptr VkSwapchainKHR
pImageIndices: ptr uint32
pResults: ptr VkResult
PFN_vkQueuePresentKHR* = proc (
queue: VkQueue;
pPresentInfo: ptr VkPresentInfoKHR;
): VkResult {.cdecl.}
VkSwapchainCreateFlagBitsKHR* {.size: sizeof(cint).} = enum
VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001
VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002
VkImageSwapchainCreateInfoKHR* = object
sType: VkStructureType
pNext: pointer
swapchain: VkSwapchainKHR
VkBindImageMemorySwapchainInfoKHR* = object
sType: VkStructureType
pNext: pointer
swapchain: VkSwapchainKHR
imageIndex: uint32
VkAcquireNextImageInfoKHR* = object
sType: VkStructureType
pNext: pointer
swapchain: VkSwapchainKHR
timeout: uint64
semaphore: VkSemaphore
fence: VkFence
deviceMask: uint32
VkDeviceGroupPresentModeFlagBitsKHR* {.size: sizeof(cint).} = enum
VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001
VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002
VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004
VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008
VkDeviceGroupPresentModeFlagsKHR* = VkFlags
VkDeviceGroupPresentCapabilitiesKHR* = object
sType: VkStructureType
pNext: pointer
presentMask: array[VK_MAX_DEVICE_GROUP_SIZE, uint32]
modes: VkDeviceGroupPresentModeFlagsKHR
VkDeviceGroupPresentInfoKHR* = object
sType: VkStructureType
pNext: pointer
swapchainCount: uint32
pDeviceMasks: ptr uint32
mode: VkDeviceGroupPresentModeFlagBitsKHR
VkDeviceGroupSwapchainCreateInfoKHR* = object
sType: VkStructureType
pNext: pointer
modes: VkDeviceGroupPresentModeFlagsKHR
PFN_vkGetDeviceGroupPresentCapabilitiesKHR* = proc (
device: VkDevice;
pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR;
): VkResult {.cdecl.}
PFN_vkGetDeviceGroupSurfacePresentModesKHR* = proc (
device: VkDevice;
surface: VkSurfaceKHR;
pModes: ptr VkDeviceGroupPresentModeFlagsKHR;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDevicePresentRectanglesKHR* = proc (
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pRectCount: ptr uint32;
pRects: ptr VkRect2D;
): VkResult {.cdecl.}
PFN_vkAcquireNextImage2KHR* = proc (
device: VkDevice;
pAcquireInfo: ptr VkAcquireNextImageInfoKHR;
pImageIndex: ptr uint32;
): VkResult {.cdecl.}
const
VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION* = 1
VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME* = "VK_AMD_draw_indirect_count"
type
PFN_vkCmdDrawIndirectCountAMD* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl.}
PFN_vkCmdDrawIndexedIndirectCountAMD* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl.}
const
VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION* = 1
VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME*
= "VK_AMD_shader_trinary_minmax"
VK_AMD_BUFFER_MARKER_SPEC_VERSION* = 1
VK_AMD_BUFFER_MARKER_EXTENSION_NAME* = "VK_AMD_buffer_marker"
type
PFN_vkCmdWriteBufferMarkerAMD* = proc (
commandBuffer: VkCommandBuffer;
pipelineStage: VkPipelineStageFlagBits;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
marker: uint32;
): void {.cdecl.}
const
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME*
= "VK_KHR_external_memory_capabilities"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO
VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
VK_LUID_SIZE_KHR* = VK_LUID_SIZE
type
VkExternalMemoryHandleTypeFlagsKHR* = VkExternalMemoryHandleTypeFlags
VkExternalMemoryHandleTypeFlagBitsKHR* = VkExternalMemoryHandleTypeFlagBits
const
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR*
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT
type
VkExternalMemoryFeatureFlagsKHR* = VkExternalMemoryFeatureFlags
VkExternalMemoryFeatureFlagBitsKHR* = VkExternalMemoryFeatureFlagBits
const
VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR*
= VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT
VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR*
= VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR*
= VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
type
VkExternalMemoryPropertiesKHR* = VkExternalMemoryProperties
VkPhysicalDeviceExternalImageFormatInfoKHR*
= VkPhysicalDeviceExternalImageFormatInfo
VkExternalImageFormatPropertiesKHR* = VkExternalImageFormatProperties
VkPhysicalDeviceExternalBufferInfoKHR* = VkPhysicalDeviceExternalBufferInfo
VkExternalBufferPropertiesKHR* = VkExternalBufferProperties
VkPhysicalDeviceIDPropertiesKHR* = VkPhysicalDeviceIDProperties
vkGetPhysicalDeviceExternalBufferPropertiesKHR*
= PFN_vkGetPhysicalDeviceExternalBufferProperties
const
VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION* = 1
VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME*
= "VK_KHR_descriptor_update_template"
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR*
= VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE
type
vkCreateDescriptorUpdateTemplateKHR* = PFN_vkCreateDescriptorUpdateTemplate
vkDestroyDescriptorUpdateTemplateKHR*
= PFN_vkDestroyDescriptorUpdateTemplate
vkUpdateDescriptorSetWithTemplateKHR*
= PFN_vkUpdateDescriptorSetWithTemplate
VkDescriptorUpdateTemplateKHR* = VkDescriptorUpdateTemplate
VkDescriptorUpdateTemplateCreateFlagsKHR*
= VkDescriptorUpdateTemplateCreateFlags
VkDescriptorUpdateTemplateTypeKHR* = VkDescriptorUpdateTemplateType
VkDescriptorUpdateTemplateEntryKHR* = VkDescriptorUpdateTemplateEntry
VkDescriptorUpdateTemplateCreateInfoKHR*
= VkDescriptorUpdateTemplateCreateInfo
const
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR*
= VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET
VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION* = 2
VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME* = "VK_KHR_push_descriptor"
type
VkDescriptorSetLayoutCreateFlagBits* {.size: sizeof(cint).} = enum
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001
VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002
PFN_vkCmdPushDescriptorSetKHR* = proc (
commandBuffer: VkCommandBuffer;
pipelineBindPoint: VkPipelineBindPoint;
layout: VkPipelineLayout;
set: uint32;
descriptorWriteCount: uint32;
pDescriptorWrites: ptr VkWriteDescriptorSet;
): void {.cdecl.}
VkPhysicalDevicePushDescriptorPropertiesKHR* = object
sType: VkStructureType
pNext: pointer
maxPushDescriptors: uint32
PFN_vkCmdPushDescriptorSetWithTemplateKHR* = proc (
commandBuffer: VkCommandBuffer;
descriptorUpdateTemplate: VkDescriptorUpdateTemplate;
layout: VkPipelineLayout;
set: uint32;
pData: pointer;
): void {.cdecl.}
const
VK_EXT_DEBUG_REPORT_SPEC_VERSION* = 9
VK_EXT_DEBUG_REPORT_EXTENSION_NAME* = "VK_EXT_debug_report"
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT*
= VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
type
VkDebugReportObjectTypeEXT* {.size: sizeof(cint).} = enum
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0
VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1
VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3
VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4
VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5
VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6
VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8
VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9
VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10
VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11
VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12
VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13
VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14
VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17
VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20
VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23
VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24
VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25
VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26
VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27
VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28
VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29
VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30
VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31
VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32
VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000
VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000
VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT = 1000165000
VkDebugReportFlagsEXT* = VkFlags
PFN_vkDebugReportCallbackEXT* = proc (
flags: VkDebugReportFlagsEXT;
objectType: VkDebugReportObjectTypeEXT;
theObject: uint64;
location: csize;
messageCode: int32;
pLayerPrefix: cstring;
pMessage: cstring;
pUserData: pointer;
): VkBool32 {.cdecl.}
VkDebugReportCallbackCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
flags: VkDebugReportFlagsEXT
pfnCallback: PFN_vkDebugReportCallbackEXT
pUserData: pointer
VkDebugReportCallbackEXT* = VkNonDispatchableHandle
PFN_vkCreateDebugReportCallbackEXT* = proc (
instance: VkInstance;
pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pCallback: ptr VkDebugReportCallbackEXT;
): VkResult {.cdecl.}
PFN_vkDestroyDebugReportCallbackEXT* = proc (
instance: VkInstance;
callback: VkDebugReportCallbackEXT;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkDebugReportMessageEXT* = proc (
instance: VkInstance;
flags: VkDebugReportFlagsEXT;
objectType: VkDebugReportObjectTypeEXT;
theObject: uint64;
location: csize;
messageCode: int32;
pLayerPrefix: cstring;
pMessage: cstring;
): void {.cdecl.}
const
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT*
= VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT
VK_KHR_16BIT_STORAGE_SPEC_VERSION* = 1
VK_KHR_16BIT_STORAGE_EXTENSION_NAME* = "VK_KHR_16bit_storage"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES
type
VkPhysicalDevice16BitStorageFeaturesKHR*
= VkPhysicalDevice16BitStorageFeatures
const
VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME* = "VK_KHR_external_semaphore"
VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
type
VkSemaphoreImportFlagsKHR* = VkSemaphoreImportFlags
VkSemaphoreImportFlagBitsKHR* = VkSemaphoreImportFlagBits
const
VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR* = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
type
VkExportSemaphoreCreateInfoKHR* = VkExportSemaphoreCreateInfo
const
VK_KHR_EXTENSION_183_SPEC_VERSION* = 0
VK_KHR_EXTENSION_183_EXTENSION_NAME* = "VK_AMD_extension_183"
VK_EXT_EXTENSION_219_SPEC_VERSION* = 0
VK_EXT_EXTENSION_219_EXTENSION_NAME* = "VK_EXT_extension_219"
type
VkAccessFlagBits* {.size: sizeof(cint).} = enum
VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001
VK_ACCESS_INDEX_READ_BIT = 0x00000002
VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004
VK_ACCESS_UNIFORM_READ_BIT = 0x00000008
VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010
VK_ACCESS_SHADER_READ_BIT = 0x00000020
VK_ACCESS_SHADER_WRITE_BIT = 0x00000040
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400
VK_ACCESS_TRANSFER_READ_BIT = 0x00000800
VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000
VK_ACCESS_HOST_READ_BIT = 0x00002000
VK_ACCESS_HOST_WRITE_BIT = 0x00004000
VK_ACCESS_MEMORY_READ_BIT = 0x00008000
VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000
VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000
VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000
VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000
VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX = 0x00200000
VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX = 0x00400000
VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000
VK_ACCESS_RESERVED_24_BIT_EXT = 0x01000000
VkImageUsageFlagBits* {.size: sizeof(cint).} = enum
VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001
VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002
VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004
VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080
VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100
VK_IMAGE_USAGE_RESERVED_9_BIT_EXT = 0x00000200
const
VK_NV_EXTENSION_152_SPEC_VERSION* = 0
VK_NV_EXTENSION_152_EXTENSION_NAME* = "VK_NV_extension_152"
VK_QCOM_extension_173_SPEC_VERSION* = 0
VK_QCOM_extension_173_EXTENSION_NAME* = "VK_QCOM_extension_173"
VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION* = 1
VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME* = "VK_EXT_direct_mode_display"
type
VkDisplayKHR* = VkNonDispatchableHandle
PFN_vkReleaseDisplayEXT* = proc (
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
): VkResult {.cdecl.}
const
VK_IMG_FORMAT_PVRTC_SPEC_VERSION* = 1
VK_IMG_FORMAT_PVRTC_EXTENSION_NAME* = "VK_IMG_format_pvrtc"
VK_EXT_VALIDATION_CACHE_SPEC_VERSION* = 1
VK_EXT_VALIDATION_CACHE_EXTENSION_NAME* = "VK_EXT_validation_cache"
type
VkValidationCacheEXT* = VkNonDispatchableHandle
VkValidationCacheCreateFlagsEXT* = VkFlags
VkValidationCacheCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
flags: VkValidationCacheCreateFlagsEXT
initialDataSize: csize
pInitialData: pointer
VkShaderModuleValidationCacheCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
validationCache: VkValidationCacheEXT
VkValidationCacheHeaderVersionEXT* {.size: sizeof(cint).} = enum
VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1
PFN_vkCreateValidationCacheEXT* = proc (
device: VkDevice;
pCreateInfo: ptr VkValidationCacheCreateInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pValidationCache: ptr VkValidationCacheEXT;
): VkResult {.cdecl.}
PFN_vkDestroyValidationCacheEXT* = proc (
device: VkDevice;
validationCache: VkValidationCacheEXT;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkMergeValidationCachesEXT* = proc (
device: VkDevice;
dstCache: VkValidationCacheEXT;
srcCacheCount: uint32;
pSrcCaches: ptr VkValidationCacheEXT;
): VkResult {.cdecl.}
PFN_vkGetValidationCacheDataEXT* = proc (
device: VkDevice;
validationCache: VkValidationCacheEXT;
pDataSize: ptr csize;
pData: pointer;
): VkResult {.cdecl.}
const
VK_AMD_EXTENSION_20_SPEC_VERSION* = 0
VK_AMD_EXTENSION_20_EXTENSION_NAME* = "VK_AMD_extension_20"
VK_AMD_EXTENSION_45_SPEC_VERSION* = 0
VK_AMD_EXTENSION_45_EXTENSION_NAME* = "VK_AMD_extension_45"
VK_AMD_GCN_SHADER_SPEC_VERSION* = 1
VK_AMD_GCN_SHADER_EXTENSION_NAME* = "VK_AMD_gcn_shader"
VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION* = 2
VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME* = "VK_NV_corner_sampled_image"
type
VkPhysicalDeviceCornerSampledImageFeaturesNV* = object
sType: VkStructureType
pNext: pointer
cornerSampledImage: VkBool32
const
VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION* = 1
VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME*
= "VK_NV_shader_image_footprint"
type
VkPhysicalDeviceShaderImageFootprintFeaturesNV* = object
sType: VkStructureType
pNext: pointer
imageFootprint: VkBool32
const
VK_KHR_EXTENSION_187_SPEC_VERSION* = 0
VK_KHR_EXTENSION_187_EXTENSION_NAME* = "VK_AMD_extension_187"
VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME*
= "VK_KHR_external_semaphore_capabilities"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES
type
VkExternalSemaphoreHandleTypeFlagsKHR* = VkExternalSemaphoreHandleTypeFlags
VkExternalSemaphoreHandleTypeFlagBitsKHR*
= VkExternalSemaphoreHandleTypeFlagBits
const
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
type
VkExternalSemaphoreFeatureFlagsKHR* = VkExternalSemaphoreFeatureFlags
VkExternalSemaphoreFeatureFlagBitsKHR* = VkExternalSemaphoreFeatureFlagBits
const
VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR*
= VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
type
VkPhysicalDeviceExternalSemaphoreInfoKHR*
= VkPhysicalDeviceExternalSemaphoreInfo
VkExternalSemaphorePropertiesKHR* = VkExternalSemaphoreProperties
vkGetPhysicalDeviceExternalSemaphorePropertiesKHR*
= PFN_vkGetPhysicalDeviceExternalSemaphoreProperties
const
VK_EXT_EXTENSION_168_SPEC_VERSION* = 0
VK_EXT_EXTENSION_168_EXTENSION_NAME* = "VK_NV_extension_168"
VK_GOOGLE_EXTENSION_196_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_196_EXTENSION_NAME* = "VK_GOOGLE_extension_196"
VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION* = 1
VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME* = "VK_KHR_relaxed_block_layout"
VK_EXT_DISPLAY_CONTROL_SPEC_VERSION* = 1
VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME* = "VK_EXT_display_control"
type
VkDisplayPowerStateEXT* {.size: sizeof(cint).} = enum
VK_DISPLAY_POWER_STATE_OFF_EXT = 0
VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1
VK_DISPLAY_POWER_STATE_ON_EXT = 2
VkDeviceEventTypeEXT* {.size: sizeof(cint).} = enum
VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0
VkDisplayEventTypeEXT* {.size: sizeof(cint).} = enum
VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0
VkDisplayPowerInfoEXT* = object
sType: VkStructureType
pNext: pointer
powerState: VkDisplayPowerStateEXT
VkDeviceEventInfoEXT* = object
sType: VkStructureType
pNext: pointer
deviceEvent: VkDeviceEventTypeEXT
VkDisplayEventInfoEXT* = object
sType: VkStructureType
pNext: pointer
displayEvent: VkDisplayEventTypeEXT
VkSurfaceCounterFlagsEXT* = VkFlags
VkSwapchainCounterCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
surfaceCounters: VkSurfaceCounterFlagsEXT
PFN_vkDisplayPowerControlEXT* = proc (
device: VkDevice;
display: VkDisplayKHR;
pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT;
): VkResult {.cdecl.}
PFN_vkRegisterDeviceEventEXT* = proc (
device: VkDevice;
pDeviceEventInfo: ptr VkDeviceEventInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pFence: ptr VkFence;
): VkResult {.cdecl.}
PFN_vkRegisterDisplayEventEXT* = proc (
device: VkDevice;
display: VkDisplayKHR;
pDisplayEventInfo: ptr VkDisplayEventInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pFence: ptr VkFence;
): VkResult {.cdecl.}
VkSurfaceCounterFlagBitsEXT* {.size: sizeof(cint).} = enum
VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001
PFN_vkGetSwapchainCounterEXT* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
counter: VkSurfaceCounterFlagBitsEXT;
pCounterValue: ptr uint64;
): VkResult {.cdecl.}
const
VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION* = 1
VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME*
= "VK_EXT_conditional_rendering"
type
VkConditionalRenderingFlagsEXT* = VkFlags
VkConditionalRenderingFlagBitsEXT* {.size: sizeof(cint).} = enum
VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001
VkBufferUsageFlagBits* {.size: sizeof(cint).} = enum
VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001
VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100
VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200
VK_BUFFER_USAGE_RAYTRACING_BIT_NVX = 0x00000400
VkConditionalRenderingBeginInfoEXT* = object
sType: VkStructureType
pNext: pointer
buffer: VkBuffer
offset: VkDeviceSize
flags: VkConditionalRenderingFlagsEXT
PFN_vkCmdBeginConditionalRenderingEXT* = proc (
commandBuffer: VkCommandBuffer;
pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT;
): void {.cdecl.}
PFN_vkCmdEndConditionalRenderingEXT* = proc (
commandBuffer: VkCommandBuffer;
): void {.cdecl.}
VkPhysicalDeviceConditionalRenderingFeaturesEXT* = object
sType: VkStructureType
pNext: pointer
conditionalRendering: VkBool32
inheritedConditionalRendering: VkBool32
VkCommandBufferInheritanceConditionalRenderingInfoEXT* = object
sType: VkStructureType
pNext: pointer
conditionalRenderingEnable: VkBool32
const
VK_NVX_EXTENSION_52_SPEC_VERSION* = 0
VK_NVX_EXTENSION_52_EXTENSION_NAME* = "VK_NVX_extension_52"
VK_NVX_EXTENSION_30_SPEC_VERSION* = 0
VK_NVX_EXTENSION_30_EXTENSION_NAME* = "VK_NVX_extension_30"
VK_AMD_EXTENSION_24_SPEC_VERSION* = 0
VK_AMD_EXTENSION_24_EXTENSION_NAME* = "VK_AMD_extension_24"
VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION* = 1
VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME* = "VK_NV_scissor_exclusive"
type
VkPipelineViewportExclusiveScissorStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
exclusiveScissorCount: uint32
pExclusiveScissors: ptr VkRect2D
VkPhysicalDeviceExclusiveScissorFeaturesNV* = object
sType: VkStructureType
pNext: pointer
exclusiveScissor: VkBool32
PFN_vkCmdSetExclusiveScissorNV* = proc (
commandBuffer: VkCommandBuffer;
firstExclusiveScissor: uint32;
exclusiveScissorCount: uint32;
pExclusiveScissors: ptr VkRect2D;
): void {.cdecl.}
const
VK_GOOGLE_EXTENSION_49_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_49_EXTENSION_NAME* = "VK_GOOGLE_extension_49"
VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION* = 1
VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME*
= "VK_KHR_get_memory_requirements2"
VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR*
= VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2
VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR*
= VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2
VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR*
= VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR*
= VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2
VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR*
= VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2
type
VkBufferMemoryRequirementsInfo2KHR* = VkBufferMemoryRequirementsInfo2
VkImageMemoryRequirementsInfo2KHR* = VkImageMemoryRequirementsInfo2
VkImageSparseMemoryRequirementsInfo2KHR*
= VkImageSparseMemoryRequirementsInfo2
VkSparseImageMemoryRequirements2KHR* = VkSparseImageMemoryRequirements2
vkGetImageMemoryRequirements2KHR* = PFN_vkGetImageMemoryRequirements2
vkGetBufferMemoryRequirements2KHR* = PFN_vkGetBufferMemoryRequirements2
vkGetImageSparseMemoryRequirements2KHR*
= PFN_vkGetImageSparseMemoryRequirements2
const
VK_NVX_EXTENSION_48_SPEC_VERSION* = 0
VK_NVX_EXTENSION_48_EXTENSION_NAME* = "VK_NVX_extension_48"
VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION* = 1
VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME*
= "VK_EXT_conservative_rasterization"
type
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
primitiveOverestimationSize: cfloat
maxExtraPrimitiveOverestimationSize: cfloat
extraPrimitiveOverestimationSizeGranularity: cfloat
primitiveUnderestimation: VkBool32
conservativePointAndLineRasterization: VkBool32
degenerateTrianglesRasterized: VkBool32
degenerateLinesRasterized: VkBool32
fullyCoveredFragmentShaderInputVariable: VkBool32
conservativeRasterizationPostDepthCoverage: VkBool32
VkPipelineRasterizationConservativeStateCreateFlagsEXT* = VkFlags
VkConservativeRasterizationModeEXT* {.size: sizeof(cint).} = enum
VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0
VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1
VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2
VkPipelineRasterizationConservativeStateCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT
conservativeRasterizationMode: VkConservativeRasterizationModeEXT
extraPrimitiveOverestimationSize: cfloat
const
VK_IMG_EXTENSION_111_SPEC_VERSION* = 0
VK_IMG_EXTENSION_111_EXTENSION_NAME* = "VK_IMG_extension_111"
VK_KHR_EXTENSION_119_SPEC_VERSION* = 0
VK_KHR_EXTENSION_119_EXTENSION_NAME* = "VK_KHR_extension_119"
VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION* = 1
VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME* = "VK_NV_dedicated_allocation"
type
VkDedicatedAllocationImageCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
dedicatedAllocation: VkBool32
VkDedicatedAllocationBufferCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
dedicatedAllocation: VkBool32
VkDedicatedAllocationMemoryAllocateInfoNV* = object
sType: VkStructureType
pNext: pointer
image: VkImage
buffer: VkBuffer
const
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION* = 1
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME*
= "VK_KHR_get_physical_device_properties2"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR*
= VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2
VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR*
= VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR*
= VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2
VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR*
= VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
type
VkPhysicalDeviceFeatures2KHR* = VkPhysicalDeviceFeatures2
VkPhysicalDeviceProperties2KHR* = VkPhysicalDeviceProperties2
VkFormatProperties2KHR* = VkFormatProperties2
VkImageFormatProperties2KHR* = VkImageFormatProperties2
VkPhysicalDeviceImageFormatInfo2KHR* = VkPhysicalDeviceImageFormatInfo2
VkQueueFamilyProperties2KHR* = VkQueueFamilyProperties2
VkPhysicalDeviceMemoryProperties2KHR* = VkPhysicalDeviceMemoryProperties2
VkSparseImageFormatProperties2KHR* = VkSparseImageFormatProperties2
VkPhysicalDeviceSparseImageFormatInfo2KHR*
= VkPhysicalDeviceSparseImageFormatInfo2
vkGetPhysicalDeviceFeatures2KHR* = PFN_vkGetPhysicalDeviceFeatures2
vkGetPhysicalDeviceProperties2KHR* = PFN_vkGetPhysicalDeviceProperties2
vkGetPhysicalDeviceFormatProperties2KHR*
= PFN_vkGetPhysicalDeviceFormatProperties2
vkGetPhysicalDeviceImageFormatProperties2KHR*
= PFN_vkGetPhysicalDeviceImageFormatProperties2
vkGetPhysicalDeviceQueueFamilyProperties2KHR*
= PFN_vkGetPhysicalDeviceQueueFamilyProperties2
vkGetPhysicalDeviceMemoryProperties2KHR*
= PFN_vkGetPhysicalDeviceMemoryProperties2
vkGetPhysicalDeviceSparseImageFormatProperties2KHR*
= PFN_vkGetPhysicalDeviceSparseImageFormatProperties2
const
VK_EXT_DEBUG_MARKER_SPEC_VERSION* = 4
VK_EXT_DEBUG_MARKER_EXTENSION_NAME* = "VK_EXT_debug_marker"
type
VkDebugMarkerObjectNameInfoEXT* = object
sType: VkStructureType
pNext: pointer
objectType: VkDebugReportObjectTypeEXT
theObject: uint64
pObjectName: cstring
VkDebugMarkerObjectTagInfoEXT* = object
sType: VkStructureType
pNext: pointer
objectType: VkDebugReportObjectTypeEXT
theObject: uint64
tagName: uint64
tagSize: csize
pTag: pointer
VkDebugMarkerMarkerInfoEXT* = object
sType: VkStructureType
pNext: pointer
pMarkerName: cstring
color: array[4, cfloat]
PFN_vkDebugMarkerSetObjectTagEXT* = proc (
device: VkDevice;
pTagInfo: ptr VkDebugMarkerObjectTagInfoEXT;
): VkResult {.cdecl.}
PFN_vkDebugMarkerSetObjectNameEXT* = proc (
device: VkDevice;
pNameInfo: ptr VkDebugMarkerObjectNameInfoEXT;
): VkResult {.cdecl.}
PFN_vkCmdDebugMarkerBeginEXT* = proc (
commandBuffer: VkCommandBuffer;
pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT;
): void {.cdecl.}
PFN_vkCmdDebugMarkerEndEXT* = proc (
commandBuffer: VkCommandBuffer;
): void {.cdecl.}
PFN_vkCmdDebugMarkerInsertEXT* = proc (
commandBuffer: VkCommandBuffer;
pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT;
): void {.cdecl.}
const
VK_KHR_EXTENSION_176_SPEC_VERSION* = 0
VK_KHR_EXTENSION_176_EXTENSION_NAME* = "VK_KHR_extension_176"
VK_GOOGLE_EXTENSION_192_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_192_EXTENSION_NAME* = "VK_GOOGLE_extension_192"
VK_IMG_EXTENSION_69_SPEC_VERSION* = 0
VK_IMG_EXTENSION_69_EXTENSION_NAME* = "VK_IMG_extension_69"
VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME* = "VK_KHR_external_memory"
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO
VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO
VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR*
= VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR* = VK_ERROR_INVALID_EXTERNAL_HANDLE
VK_QUEUE_FAMILY_EXTERNAL_KHR* = VK_QUEUE_FAMILY_EXTERNAL
type
VkExternalMemoryImageCreateInfoKHR* = VkExternalMemoryImageCreateInfo
VkExternalMemoryBufferCreateInfoKHR* = VkExternalMemoryBufferCreateInfo
VkExportMemoryAllocateInfoKHR* = VkExportMemoryAllocateInfo
const
VK_QCOM_extension_174_SPEC_VERSION* = 0
VK_QCOM_extension_174_EXTENSION_NAME* = "VK_QCOM_extension_174"
VK_NV_FILL_RECTANGLE_SPEC_VERSION* = 1
VK_NV_FILL_RECTANGLE_EXTENSION_NAME* = "VK_NV_fill_rectangle"
VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION* = 1
VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME*
= "VK_KHR_shader_draw_parameters"
VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME* = "VK_KHR_external_fence_fd"
type
VkImportFenceFdInfoKHR* = object
sType: VkStructureType
pNext: pointer
fence: VkFence
flags: VkFenceImportFlags
handleType: VkExternalFenceHandleTypeFlagBits
fd: int
VkFenceGetFdInfoKHR* = object
sType: VkStructureType
pNext: pointer
fence: VkFence
handleType: VkExternalFenceHandleTypeFlagBits
PFN_vkImportFenceFdKHR* = proc (
device: VkDevice;
pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR;
): VkResult {.cdecl.}
PFN_vkGetFenceFdKHR* = proc (
device: VkDevice;
pGetFdInfo: ptr VkFenceGetFdInfoKHR;
pFd: ptr int;
): VkResult {.cdecl.}
const
VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION* = 1
VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME*
= "VK_EXT_display_surface_counter"
# VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT* = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
type
VkSurfaceTransformFlagsKHR* = VkFlags
VkCompositeAlphaFlagsKHR* = VkFlags
VkSurfaceCapabilities2EXT* = object
sType: VkStructureType
pNext: pointer
minImageCount: uint32
maxImageCount: uint32
currentExtent: VkExtent2D
minImageExtent: VkExtent2D
maxImageExtent: VkExtent2D
maxImageArrayLayers: uint32
supportedTransforms: VkSurfaceTransformFlagsKHR
currentTransform: VkSurfaceTransformFlagBitsKHR
supportedCompositeAlpha: VkCompositeAlphaFlagsKHR
supportedUsageFlags: VkImageUsageFlags
supportedSurfaceCounters: VkSurfaceCounterFlagsEXT
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT* = proc (
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT;
): VkResult {.cdecl.}
const
VK_KHR_EXTENSION_117_SPEC_VERSION* = 0
VK_KHR_EXTENSION_117_EXTENSION_NAME* = "VK_KHR_extension_117"
VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION* = 1
VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME*
= "VK_KHR_sampler_ycbcr_conversion"
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR*
= VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO
VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR*
= VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO
VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR*
= VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT*
= VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT
VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR*
= VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION
VK_FORMAT_G8B8G8R8_422_UNORM_KHR* = VK_FORMAT_G8B8G8R8_422_UNORM
VK_FORMAT_B8G8R8G8_422_UNORM_KHR* = VK_FORMAT_B8G8R8G8_422_UNORM
VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR*
= VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR*
= VK_FORMAT_G8_B8R8_2PLANE_420_UNORM
VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR*
= VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM
VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR*
= VK_FORMAT_G8_B8R8_2PLANE_422_UNORM
VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR*
= VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM
VK_FORMAT_R10X6_UNORM_PACK16_KHR* = VK_FORMAT_R10X6_UNORM_PACK16
VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR*
= VK_FORMAT_R10X6G10X6_UNORM_2PACK16
VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR*
= VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16
VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR*
= VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16
VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR*
= VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR*
= VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR*
= VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR*
= VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16
VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR*
= VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16
VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR*
= VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16
VK_FORMAT_R12X4_UNORM_PACK16_KHR* = VK_FORMAT_R12X4_UNORM_PACK16
VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR*
= VK_FORMAT_R12X4G12X4_UNORM_2PACK16
VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR*
= VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16
VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR*
= VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16
VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR*
= VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR*
= VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR*
= VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR*
= VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16
VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR*
= VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16
VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR*
= VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16
VK_FORMAT_G16B16G16R16_422_UNORM_KHR* = VK_FORMAT_G16B16G16R16_422_UNORM
VK_FORMAT_B16G16R16G16_422_UNORM_KHR* = VK_FORMAT_B16G16R16G16_422_UNORM
VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR*
= VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM
VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR*
= VK_FORMAT_G16_B16R16_2PLANE_420_UNORM
VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR*
= VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM
VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR*
= VK_FORMAT_G16_B16R16_2PLANE_422_UNORM
VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR*
= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
VK_IMAGE_ASPECT_PLANE_0_BIT_KHR* = VK_IMAGE_ASPECT_PLANE_0_BIT
VK_IMAGE_ASPECT_PLANE_1_BIT_KHR* = VK_IMAGE_ASPECT_PLANE_1_BIT
VK_IMAGE_ASPECT_PLANE_2_BIT_KHR* = VK_IMAGE_ASPECT_PLANE_2_BIT
VK_IMAGE_CREATE_DISJOINT_BIT_KHR* = VK_IMAGE_CREATE_DISJOINT_BIT
VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR*
= VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR*
= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR* = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR* = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT
VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR* = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT
VK_FORMAT_FEATURE_DISJOINT_BIT_KHR* = VK_FORMAT_FEATURE_DISJOINT_BIT
VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR*
= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT
type
VkSamplerYcbcrConversionCreateInfoKHR* = VkSamplerYcbcrConversionCreateInfo
VkSamplerYcbcrConversionInfoKHR* = VkSamplerYcbcrConversionInfo
VkBindImagePlaneMemoryInfoKHR* = VkBindImagePlaneMemoryInfo
VkImagePlaneMemoryRequirementsInfoKHR* = VkImagePlaneMemoryRequirementsInfo
VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR*
= VkPhysicalDeviceSamplerYcbcrConversionFeatures
VkSamplerYcbcrConversionImageFormatPropertiesKHR*
= VkSamplerYcbcrConversionImageFormatProperties
vkCreateSamplerYcbcrConversionKHR* = PFN_vkCreateSamplerYcbcrConversion
vkDestroySamplerYcbcrConversionKHR* = PFN_vkDestroySamplerYcbcrConversion
VkSamplerYcbcrConversionKHR* = VkSamplerYcbcrConversion
VkSamplerYcbcrModelConversionKHR* = VkSamplerYcbcrModelConversion
const
VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR*
= VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR*
= VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR*
= VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR*
= VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR*
= VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
type
VkSamplerYcbcrRangeKHR* = VkSamplerYcbcrRange
const
VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR* = VK_SAMPLER_YCBCR_RANGE_ITU_FULL
VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR* = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
type
VkChromaLocationKHR* = VkChromaLocation
const
VK_CHROMA_LOCATION_COSITED_EVEN_KHR* = VK_CHROMA_LOCATION_COSITED_EVEN
VK_CHROMA_LOCATION_MIDPOINT_KHR* = VK_CHROMA_LOCATION_MIDPOINT
VK_NV_EXTENSION_151_SPEC_VERSION* = 0
VK_NV_EXTENSION_151_EXTENSION_NAME* = "VK_NV_extension_151"
VK_EXT_VALIDATION_FLAGS_SPEC_VERSION* = 1
VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME* = "VK_EXT_validation_flags"
type
VkValidationCheckEXT* {.size: sizeof(cint).} = enum
VK_VALIDATION_CHECK_ALL_EXT = 0
VK_VALIDATION_CHECK_SHADERS_EXT = 1
VkValidationFlagsEXT* = object
sType: VkStructureType
pNext: pointer
disabledValidationCheckCount: uint32
pDisabledValidationChecks: ptr VkValidationCheckEXT
const
VK_KHR_MAINTENANCE2_SPEC_VERSION* = 1
VK_KHR_MAINTENANCE2_EXTENSION_NAME* = "VK_KHR_maintenance2"
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR*
= VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR*
= VK_IMAGE_CREATE_EXTENDED_USAGE_BIT
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR*
= VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR*
= VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
type
VkPhysicalDevicePointClippingPropertiesKHR*
= VkPhysicalDevicePointClippingProperties
VkPointClippingBehaviorKHR* = VkPointClippingBehavior
const
VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR*
= VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES
VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR*
= VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
type
VkRenderPassInputAttachmentAspectCreateInfoKHR*
= VkRenderPassInputAttachmentAspectCreateInfo
VkInputAttachmentAspectReferenceKHR* = VkInputAttachmentAspectReference
VkImageViewUsageCreateInfoKHR* = VkImageViewUsageCreateInfo
VkTessellationDomainOriginKHR* = VkTessellationDomainOrigin
const
VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR*
= VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT
VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR*
= VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
type
VkPipelineTessellationDomainOriginStateCreateInfoKHR*
= VkPipelineTessellationDomainOriginStateCreateInfo
const
VK_IMG_EXTENSION_109_SPEC_VERSION* = 0
VK_IMG_EXTENSION_109_EXTENSION_NAME* = "VK_IMG_extension_109"
VK_AMD_EXTENSION_33_SPEC_VERSION* = 0
VK_AMD_EXTENSION_33_EXTENSION_NAME* = "VK_AMD_extension_33"
VK_EXT_EXTENSION_197_SPEC_VERSION* = 0
VK_EXT_EXTENSION_197_EXTENSION_NAME* = "VK_EXT_extension_197"
VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION* = 1
VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME* = "VK_KHR_create_renderpass2"
type
VkAttachmentDescription2KHR* = object
sType: VkStructureType
pNext: pointer
flags: VkAttachmentDescriptionFlags
format: VkFormat
samples: VkSampleCountFlagBits
loadOp: VkAttachmentLoadOp
storeOp: VkAttachmentStoreOp
stencilLoadOp: VkAttachmentLoadOp
stencilStoreOp: VkAttachmentStoreOp
initialLayout: VkImageLayout
finalLayout: VkImageLayout
VkAttachmentReference2KHR* = object
sType: VkStructureType
pNext: pointer
attachment: uint32
layout: VkImageLayout
aspectMask: VkImageAspectFlags
VkSubpassDescription2KHR* = object
sType: VkStructureType
pNext: pointer
flags: VkSubpassDescriptionFlags
pipelineBindPoint: VkPipelineBindPoint
viewMask: uint32
inputAttachmentCount: uint32
pInputAttachments: ptr VkAttachmentReference2KHR
colorAttachmentCount: uint32
pColorAttachments: ptr VkAttachmentReference2KHR
pResolveAttachments: ptr VkAttachmentReference2KHR
pDepthStencilAttachment: ptr VkAttachmentReference2KHR
preserveAttachmentCount: uint32
pPreserveAttachments: ptr uint32
VkSubpassDependency2KHR* = object
sType: VkStructureType
pNext: pointer
srcSubpass: uint32
dstSubpass: uint32
srcStageMask: VkPipelineStageFlags
dstStageMask: VkPipelineStageFlags
srcAccessMask: VkAccessFlags
dstAccessMask: VkAccessFlags
dependencyFlags: VkDependencyFlags
viewOffset: int32
VkRenderPassCreateInfo2KHR* = object
sType: VkStructureType
pNext: pointer
flags: VkRenderPassCreateFlags
attachmentCount: uint32
pAttachments: ptr VkAttachmentDescription2KHR
subpassCount: uint32
pSubpasses: ptr VkSubpassDescription2KHR
dependencyCount: uint32
pDependencies: ptr VkSubpassDependency2KHR
correlatedViewMaskCount: uint32
pCorrelatedViewMasks: ptr uint32
PFN_vkCreateRenderPass2KHR* = proc (
device: VkDevice;
pCreateInfo: ptr VkRenderPassCreateInfo2KHR;
pAllocator: ptr VkAllocationCallbacks;
pRenderPass: ptr VkRenderPass;
): VkResult {.cdecl.}
VkSubpassBeginInfoKHR* = object
sType: VkStructureType
pNext: pointer
contents: VkSubpassContents
PFN_vkCmdBeginRenderPass2KHR* = proc (
commandBuffer: VkCommandBuffer;
pRenderPassBegin: ptr VkRenderPassBeginInfo;
pSubpassBeginInfo: ptr VkSubpassBeginInfoKHR;
): void {.cdecl.}
VkSubpassEndInfoKHR* = object
sType: VkStructureType
pNext: pointer
PFN_vkCmdNextSubpass2KHR* = proc (
commandBuffer: VkCommandBuffer;
pSubpassBeginInfo: ptr VkSubpassBeginInfoKHR;
pSubpassEndInfo: ptr VkSubpassEndInfoKHR;
): void {.cdecl.}
PFN_vkCmdEndRenderPass2KHR* = proc (
commandBuffer: VkCommandBuffer;
pSubpassEndInfo: ptr VkSubpassEndInfoKHR;
): void {.cdecl.}
const
VK_GOOGLE_EXTENSION_195_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_195_EXTENSION_NAME* = "VK_GOOGLE_extension_195"
VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION* = 1
VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME* = "VK_EXT_external_memory_host"
type
VkImportMemoryHostPointerInfoEXT* = object
sType: VkStructureType
pNext: pointer
handleType: VkExternalMemoryHandleTypeFlagBits
pHostPointer: pointer
VkMemoryHostPointerPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
memoryTypeBits: uint32
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
minImportedHostPointerAlignment: VkDeviceSize
PFN_vkGetMemoryHostPointerPropertiesEXT* = proc (
device: VkDevice;
handleType: VkExternalMemoryHandleTypeFlagBits;
pHostPointer: pointer;
pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT;
): VkResult {.cdecl.}
const
VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION* = 1
VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME*
= "VK_EXT_shader_subgroup_ballot"
VK_KHR_EXTERNAL_FENCE_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME* = "VK_KHR_external_fence"
VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
type
VkFenceImportFlagsKHR* = VkFenceImportFlags
VkFenceImportFlagBitsKHR* = VkFenceImportFlagBits
const
VK_FENCE_IMPORT_TEMPORARY_BIT_KHR* = VK_FENCE_IMPORT_TEMPORARY_BIT
type
VkExportFenceCreateInfoKHR* = VkExportFenceCreateInfo
const
VK_EXT_MACOS_IOS_WINDOW_SPEC_VERSION* = 0
VK_EXT_MACOS_IOS_WINDOW_EXTENSION_NAME* = "VK_EXT_macos_ios_window"
VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION* = 1
VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME*
= "VK_EXT_shader_viewport_index_layer"
VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION* = 1
VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME*
= "VK_AMD_shader_core_properties"
type
VkPhysicalDeviceShaderCorePropertiesAMD* = object
sType: VkStructureType
pNext: pointer
shaderEngineCount: uint32
shaderArraysPerEngineCount: uint32
computeUnitsPerShaderArray: uint32
simdPerComputeUnit: uint32
wavefrontsPerSimd: uint32
wavefrontSize: uint32
sgprsPerSimd: uint32
minSgprAllocation: uint32
maxSgprAllocation: uint32
sgprAllocationGranularity: uint32
vgprsPerSimd: uint32
minVgprAllocation: uint32
maxVgprAllocation: uint32
vgprAllocationGranularity: uint32
const
VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION* = 3
VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME*
= "VK_EXT_vertex_attribute_divisor"
type
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
maxVertexAttribDivisor: uint32
VkVertexInputBindingDivisorDescriptionEXT* = object
binding: uint32
divisor: uint32
VkPipelineVertexInputDivisorStateCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
vertexBindingDivisorCount: uint32
pVertexBindingDivisors: ptr VkVertexInputBindingDivisorDescriptionEXT
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* = object
sType: VkStructureType
pNext: pointer
vertexAttributeInstanceRateDivisor: VkBool32
vertexAttributeInstanceRateZeroDivisor: VkBool32
const
VK_MVK_MOLTENVK_SPEC_VERSION* = 0
VK_MVK_MOLTENVK_EXTENSION_NAME* = "VK_MVK_moltenvk"
VK_AMD_EXTENSION_140_SPEC_VERSION* = 0
VK_AMD_EXTENSION_140_EXTENSION_NAME* = "VK_AMD_extension_140"
VK_KHR_EXTENSION_209_SPEC_VERSION* = 0
VK_KHR_EXTENSION_209_EXTENSION_NAME* = "VK_KHR_extension_209"
VK_AMD_EXTENSION_46_SPEC_VERSION* = 0
VK_AMD_EXTENSION_46_EXTENSION_NAME* = "VK_AMD_extension_46"
VK_IMG_FILTER_CUBIC_SPEC_VERSION* = 1
VK_IMG_FILTER_CUBIC_EXTENSION_NAME* = "VK_IMG_filter_cubic"
VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION* = 1
VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME*
= "VK_KHR_sampler_mirror_clamp_to_edge"
VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME*
= "VK_KHR_external_fence_capabilities"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO
VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES
type
VkExternalFenceHandleTypeFlagsKHR* = VkExternalFenceHandleTypeFlags
VkExternalFenceHandleTypeFlagBitsKHR* = VkExternalFenceHandleTypeFlagBits
const
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR*
= VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR*
= VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR*
= VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR*
= VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
type
VkExternalFenceFeatureFlagsKHR* = VkExternalFenceFeatureFlags
VkExternalFenceFeatureFlagBitsKHR* = VkExternalFenceFeatureFlagBits
const
VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR*
= VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT
VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR*
= VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
type
VkPhysicalDeviceExternalFenceInfoKHR* = VkPhysicalDeviceExternalFenceInfo
VkExternalFencePropertiesKHR* = VkExternalFenceProperties
vkGetPhysicalDeviceExternalFencePropertiesKHR*
= PFN_vkGetPhysicalDeviceExternalFenceProperties
const
VK_AMD_EXTENSION_134_SPEC_VERSION* = 0
VK_AMD_EXTENSION_134_EXTENSION_NAME* = "VK_AMD_extension_134"
VK_EXT_EXTENSION_164_SPEC_VERSION* = 0
VK_EXT_EXTENSION_164_EXTENSION_NAME* = "VK_NV_extension_164"
VK_KHR_EXTENSION_214_SPEC_VERSION* = 0
VK_KHR_EXTENSION_214_EXTENSION_NAME* = "VK_KHR_extension_214"
VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION* = 1
VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME*
= "VK_EXT_sampler_filter_minmax"
type
VkSamplerReductionModeEXT* {.size: sizeof(cint).} = enum
VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0
VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1
VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2
VkSamplerReductionModeCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
reductionMode: VkSamplerReductionModeEXT
VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
filterMinmaxSingleComponentFormats: VkBool32
filterMinmaxImageComponentMapping: VkBool32
const
VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION* = 2
VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME* = "VK_EXT_global_priority"
type
VkQueueGlobalPriorityEXT* {.size: sizeof(cint).} = enum
VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128
VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256
VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512
VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024
VkDeviceQueueGlobalPriorityCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
globalPriority: VkQueueGlobalPriorityEXT
const
VK_KHR_DISPLAY_SPEC_VERSION* = 21
VK_KHR_DISPLAY_EXTENSION_NAME* = "VK_KHR_display"
type
VkDisplayPlaneAlphaFlagsKHR* = VkFlags
VkDisplayPlaneAlphaFlagBitsKHR* {.size: sizeof(cint).} = enum
VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001
VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008
VkDisplayPropertiesKHR* = object
display: VkDisplayKHR
displayName: cstring
physicalDimensions: VkExtent2D
physicalResolution: VkExtent2D
supportedTransforms: VkSurfaceTransformFlagsKHR
planeReorderPossible: VkBool32
persistentContent: VkBool32
VkDisplayModeParametersKHR* = object
visibleRegion: VkExtent2D
refreshRate: uint32
VkDisplayModeKHR* = VkNonDispatchableHandle
VkDisplayModePropertiesKHR* = object
displayMode: VkDisplayModeKHR
parameters: VkDisplayModeParametersKHR
VkDisplayModeCreateFlagsKHR* = VkFlags
VkDisplayModeCreateInfoKHR* = object
sType: VkStructureType
pNext: pointer
flags: VkDisplayModeCreateFlagsKHR
parameters: VkDisplayModeParametersKHR
VkDisplayPlaneCapabilitiesKHR* = object
supportedAlpha: VkDisplayPlaneAlphaFlagsKHR
minSrcPosition: VkOffset2D
maxSrcPosition: VkOffset2D
minSrcExtent: VkExtent2D
maxSrcExtent: VkExtent2D
minDstPosition: VkOffset2D
maxDstPosition: VkOffset2D
minDstExtent: VkExtent2D
maxDstExtent: VkExtent2D
VkDisplayPlanePropertiesKHR* = object
currentDisplay: VkDisplayKHR
currentStackIndex: uint32
VkDisplaySurfaceCreateFlagsKHR* = VkFlags
VkDisplaySurfaceCreateInfoKHR* = object
sType: VkStructureType
pNext: pointer
flags: VkDisplaySurfaceCreateFlagsKHR
displayMode: VkDisplayModeKHR
planeIndex: uint32
planeStackIndex: uint32
transform: VkSurfaceTransformFlagBitsKHR
globalAlpha: cfloat
alphaMode: VkDisplayPlaneAlphaFlagBitsKHR
imageExtent: VkExtent2D
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR* = proc (
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayPropertiesKHR;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR* = proc (
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayPlanePropertiesKHR;
): VkResult {.cdecl.}
PFN_vkGetDisplayPlaneSupportedDisplaysKHR* = proc (
physicalDevice: VkPhysicalDevice;
planeIndex: uint32;
pDisplayCount: ptr uint32;
pDisplays: ptr VkDisplayKHR;
): VkResult {.cdecl.}
PFN_vkGetDisplayModePropertiesKHR* = proc (
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayModePropertiesKHR;
): VkResult {.cdecl.}
PFN_vkCreateDisplayModeKHR* = proc (
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
pCreateInfo: ptr VkDisplayModeCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pMode: ptr VkDisplayModeKHR;
): VkResult {.cdecl.}
PFN_vkGetDisplayPlaneCapabilitiesKHR* = proc (
physicalDevice: VkPhysicalDevice;
mode: VkDisplayModeKHR;
planeIndex: uint32;
pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR;
): VkResult {.cdecl.}
PFN_vkCreateDisplayPlaneSurfaceKHR* = proc (
instance: VkInstance;
pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pSurface: ptr VkSurfaceKHR;
): VkResult {.cdecl.}
const
VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION* = 1
VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME*
= "VK_AMD_shader_explicit_vertex_parameter"
VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION* = 1
VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME* = "VK_KHR_incremental_present"
type
VkRectLayerKHR* = object
offset: VkOffset2D
extent: VkExtent2D
layer: uint32
VkPresentRegionKHR* = object
rectangleCount: uint32
pRectangles: ptr VkRectLayerKHR
VkPresentRegionsKHR* = object
sType: VkStructureType
pNext: pointer
swapchainCount: uint32
pRegions: ptr VkPresentRegionKHR
const
VK_KHR_EXTENSION_213_SPEC_VERSION* = 0
VK_KHR_EXTENSION_213_EXTENSION_NAME* = "VK_KHR_extension_213"
VK_EXT_EXTENSION_159_SPEC_VERSION* = 0
VK_EXT_EXTENSION_159_EXTENSION_NAME* = "VK_EXT_extension_159"
VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION* = 1
VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME* = "VK_GOOGLE_display_timing"
type
VkRefreshCycleDurationGOOGLE* = object
refreshDuration: uint64
VkPastPresentationTimingGOOGLE* = object
presentID: uint32
desiredPresentTime: uint64
actualPresentTime: uint64
earliestPresentTime: uint64
presentMargin: uint64
VkPresentTimeGOOGLE* = object
presentID: uint32
desiredPresentTime: uint64
VkPresentTimesInfoGOOGLE* = object
sType: VkStructureType
pNext: pointer
swapchainCount: uint32
pTimes: ptr VkPresentTimeGOOGLE
PFN_vkGetRefreshCycleDurationGOOGLE* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE;
): VkResult {.cdecl.}
PFN_vkGetPastPresentationTimingGOOGLE* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
pPresentationTimingCount: ptr uint32;
pPresentationTimings: ptr VkPastPresentationTimingGOOGLE;
): VkResult {.cdecl.}
const
VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION* = 1
VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME* = "VK_EXT_sample_locations"
type
VkSampleLocationEXT* = object
x: cfloat
y: cfloat
VkSampleLocationsInfoEXT* = object
sType: VkStructureType
pNext: pointer
sampleLocationsPerPixel: VkSampleCountFlagBits
sampleLocationGridSize: VkExtent2D
sampleLocationsCount: uint32
pSampleLocations: ptr VkSampleLocationEXT
VkAttachmentSampleLocationsEXT* = object
attachmentIndex: uint32
sampleLocationsInfo: VkSampleLocationsInfoEXT
VkSubpassSampleLocationsEXT* = object
subpassIndex: uint32
sampleLocationsInfo: VkSampleLocationsInfoEXT
VkRenderPassSampleLocationsBeginInfoEXT* = object
sType: VkStructureType
pNext: pointer
attachmentInitialSampleLocationsCount: uint32
pAttachmentInitialSampleLocations: ptr VkAttachmentSampleLocationsEXT
postSubpassSampleLocationsCount: uint32
pPostSubpassSampleLocations: ptr VkSubpassSampleLocationsEXT
VkPipelineSampleLocationsStateCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
sampleLocationsEnable: VkBool32
sampleLocationsInfo: VkSampleLocationsInfoEXT
VkPhysicalDeviceSampleLocationsPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
sampleLocationSampleCounts: VkSampleCountFlags
maxSampleLocationGridSize: VkExtent2D
sampleLocationCoordinateRange: array[2, cfloat]
sampleLocationSubPixelBits: uint32
variableSampleLocations: VkBool32
VkMultisamplePropertiesEXT* = object
sType: VkStructureType
pNext: pointer
maxSampleLocationGridSize: VkExtent2D
PFN_vkCmdSetSampleLocationsEXT* = proc (
commandBuffer: VkCommandBuffer;
pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT* = proc (
physicalDevice: VkPhysicalDevice;
samples: VkSampleCountFlagBits;
pMultisampleProperties: ptr VkMultisamplePropertiesEXT;
): void {.cdecl.}
const
VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION* = 1
VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME* = "VK_AMD_shader_fragment_mask"
VK_AMD_EXTENSION_136_SPEC_VERSION* = 0
VK_AMD_EXTENSION_136_EXTENSION_NAME* = "VK_AMD_extension_136"
VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION* = 2
VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME* = "VK_KHR_vulkan_memory_model"
type
VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* = object
sType: VkStructureType
pNext: pointer
vulkanMemoryModel: VkBool32
vulkanMemoryModelDeviceScope: VkBool32
const
VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION* = 1
VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME* = "VK_EXT_discard_rectangles"
type
VkPhysicalDeviceDiscardRectanglePropertiesEXT* = object
sType: VkStructureType
pNext: pointer
maxDiscardRectangles: uint32
VkPipelineDiscardRectangleStateCreateFlagsEXT* = VkFlags
VkDiscardRectangleModeEXT* {.size: sizeof(cint).} = enum
VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0
VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1
VkPipelineDiscardRectangleStateCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineDiscardRectangleStateCreateFlagsEXT
discardRectangleMode: VkDiscardRectangleModeEXT
discardRectangleCount: uint32
pDiscardRectangles: ptr VkRect2D
PFN_vkCmdSetDiscardRectangleEXT* = proc (
commandBuffer: VkCommandBuffer;
firstDiscardRectangle: uint32;
discardRectangleCount: uint32;
pDiscardRectangles: ptr VkRect2D;
): void {.cdecl.}
const
VK_EXT_EXTENSION_160_SPEC_VERSION* = 0
VK_EXT_EXTENSION_160_EXTENSION_NAME* = "VK_EXT_extension_160"
VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION* = 1
VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME* = "VK_KHR_draw_indirect_count"
type
PFN_vkCmdDrawIndirectCountKHR* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl.}
PFN_vkCmdDrawIndexedIndirectCountKHR* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl.}
const
VK_KHR_EXTENSION_177_SPEC_VERSION* = 0
VK_KHR_EXTENSION_177_EXTENSION_NAME* = "VK_KHR_extension_177"
VK_AMD_SHADER_INFO_SPEC_VERSION* = 1
VK_AMD_SHADER_INFO_EXTENSION_NAME* = "VK_AMD_shader_info"
type
VkShaderInfoTypeAMD* {.size: sizeof(cint).} = enum
VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0
VK_SHADER_INFO_TYPE_BINARY_AMD = 1
VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2
VkShaderResourceUsageAMD* = object
numUsedVgprs: uint32
numUsedSgprs: uint32
ldsSizePerLocalWorkGroup: uint32
ldsUsageSizeInBytes: csize
scratchMemUsageInBytes: csize
VkShaderStatisticsInfoAMD* = object
shaderStageMask: VkShaderStageFlags
resourceUsage: VkShaderResourceUsageAMD
numPhysicalVgprs: uint32
numPhysicalSgprs: uint32
numAvailableVgprs: uint32
numAvailableSgprs: uint32
computeWorkGroupSize: array[3, uint32]
PFN_vkGetShaderInfoAMD* = proc (
device: VkDevice;
pipeline: VkPipeline;
shaderStage: VkShaderStageFlagBits;
infoType: VkShaderInfoTypeAMD;
pInfoSize: ptr csize;
pInfo: pointer;
): VkResult {.cdecl.}
const
VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION* = 3
VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME* = "VK_KHR_dedicated_allocation"
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR*
= VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR*
= VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO
type
VkMemoryDedicatedRequirementsKHR* = VkMemoryDedicatedRequirements
VkMemoryDedicatedAllocateInfoKHR* = VkMemoryDedicatedAllocateInfo
const
VK_GOOGLE_EXTENSION_50_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_50_EXTENSION_NAME* = "VK_GOOGLE_extension_50"
VK_AMD_EXTENSION_44_SPEC_VERSION* = 0
VK_AMD_EXTENSION_44_EXTENSION_NAME* = "VK_AMD_extension_44"
VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION* = 1
VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME*
= "VK_NV_compute_shader_derivatives"
type
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* = object
sType: VkStructureType
pNext: pointer
computeDerivativeGroupQuads: VkBool32
computeDerivativeGroupLinear: VkBool32
const
VK_NV_EXTENSION_53_SPEC_VERSION* = 0
VK_NV_EXTENSION_53_EXTENSION_NAME* = "VK_NV_extension_53"
VK_AMD_EXTENSION_41_SPEC_VERSION* = 0
VK_AMD_EXTENSION_41_EXTENSION_NAME* = "VK_AMD_extension_41"
VK_AMD_EXTENSION_17_SPEC_VERSION* = 0
VK_AMD_EXTENSION_17_EXTENSION_NAME* = "VK_AMD_extension_17"
VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION* = 1
VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME* = "VK_EXT_inline_uniform_block"
type
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* = object
sType: VkStructureType
pNext: pointer
inlineUniformBlock: VkBool32
descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
maxInlineUniformBlockSize: uint32
maxPerStageDescriptorInlineUniformBlocks: uint32
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32
maxDescriptorSetInlineUniformBlocks: uint32
maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32
VkWriteDescriptorSetInlineUniformBlockEXT* = object
sType: VkStructureType
pNext: pointer
dataSize: uint32
pData: pointer
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
maxInlineUniformBlockBindings: uint32
const
VK_AMD_EXTENSION_18_SPEC_VERSION* = 0
VK_AMD_EXTENSION_18_EXTENSION_NAME* = "VK_AMD_extension_18"
VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION* = 1
VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME*
= "VK_KHR_device_group_creation"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO
VK_MAX_DEVICE_GROUP_SIZE_KHR* = VK_MAX_DEVICE_GROUP_SIZE
type
VkPhysicalDeviceGroupPropertiesKHR* = VkPhysicalDeviceGroupProperties
VkDeviceGroupDeviceCreateInfoKHR* = VkDeviceGroupDeviceCreateInfo
vkEnumeratePhysicalDeviceGroupsKHR* = PFN_vkEnumeratePhysicalDeviceGroups
const
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR* = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION* = 1
VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME*
= "VK_NV_sample_mask_override_coverage"
VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION* = 1
VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME*
= "VK_KHR_get_display_properties2"
type
VkDisplayProperties2KHR* = object
sType: VkStructureType
pNext: pointer
displayProperties: VkDisplayPropertiesKHR
VkDisplayPlaneProperties2KHR* = object
sType: VkStructureType
pNext: pointer
displayPlaneProperties: VkDisplayPlanePropertiesKHR
VkDisplayModeProperties2KHR* = object
sType: VkStructureType
pNext: pointer
displayModeProperties: VkDisplayModePropertiesKHR
VkDisplayPlaneInfo2KHR* = object
sType: VkStructureType
pNext: pointer
mode: VkDisplayModeKHR
planeIndex: uint32
VkDisplayPlaneCapabilities2KHR* = object
sType: VkStructureType
pNext: pointer
capabilities: VkDisplayPlaneCapabilitiesKHR
PFN_vkGetPhysicalDeviceDisplayProperties2KHR* = proc (
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayProperties2KHR;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR* = proc (
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayPlaneProperties2KHR;
): VkResult {.cdecl.}
PFN_vkGetDisplayModeProperties2KHR* = proc (
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayModeProperties2KHR;
): VkResult {.cdecl.}
PFN_vkGetDisplayPlaneCapabilities2KHR* = proc (
physicalDevice: VkPhysicalDevice;
pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR;
pCapabilities: ptr VkDisplayPlaneCapabilities2KHR;
): VkResult {.cdecl.}
const
VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION* = 2
VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME*
= "VK_EXT_blend_operation_advanced"
type
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* = object
sType: VkStructureType
pNext: pointer
advancedBlendCoherentOperations: VkBool32
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
advancedBlendMaxColorAttachments: uint32
advancedBlendIndependentBlend: VkBool32
advancedBlendNonPremultipliedSrcColor: VkBool32
advancedBlendNonPremultipliedDstColor: VkBool32
advancedBlendCorrelatedOverlap: VkBool32
advancedBlendAllOperations: VkBool32
VkBlendOverlapEXT* {.size: sizeof(cint).} = enum
VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0
VK_BLEND_OVERLAP_DISJOINT_EXT = 1
VK_BLEND_OVERLAP_CONJOINT_EXT = 2
VkPipelineColorBlendAdvancedStateCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
srcPremultiplied: VkBool32
dstPremultiplied: VkBool32
blendOverlap: VkBlendOverlapEXT
const
VK_KHR_EXTENSION_181_SPEC_VERSION* = 0
VK_KHR_EXTENSION_181_EXTENSION_NAME* = "VK_AMD_extension_181"
VK_AMD_EXTENSION_35_SPEC_VERSION* = 0
VK_AMD_EXTENSION_35_EXTENSION_NAME* = "VK_AMD_extension_35"
VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION* = 1
VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME* = "VK_EXT_shader_subgroup_vote"
VK_KHR_BIND_MEMORY_2_SPEC_VERSION* = 1
VK_KHR_BIND_MEMORY_2_EXTENSION_NAME* = "VK_KHR_bind_memory2"
type
vkBindBufferMemory2KHR* = PFN_vkBindBufferMemory2
vkBindImageMemory2KHR* = PFN_vkBindImageMemory2
const
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR*
= VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR*
= VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO
VK_IMAGE_CREATE_ALIAS_BIT_KHR* = VK_IMAGE_CREATE_ALIAS_BIT
type
VkBindBufferMemoryInfoKHR* = VkBindBufferMemoryInfo
VkBindImageMemoryInfoKHR* = VkBindImageMemoryInfo
const
VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION* = 1
VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME* = "VK_AMD_rasterization_order"
type
VkRasterizationOrderAMD* {.size: sizeof(cint).} = enum
VK_RASTERIZATION_ORDER_STRICT_AMD = 0
VK_RASTERIZATION_ORDER_RELAXED_AMD = 1
VkPipelineRasterizationStateRasterizationOrderAMD* = object
sType: VkStructureType
pNext: pointer
rasterizationOrder: VkRasterizationOrderAMD
const
VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION* = 3
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME*
= "VK_NVX_device_generated_commands"
type
VkObjectTableNVX* = VkNonDispatchableHandle
VkIndirectCommandsLayoutNVX* = VkNonDispatchableHandle
VkIndirectCommandsLayoutUsageFlagsNVX* = VkFlags
VkObjectEntryUsageFlagsNVX* = VkFlags
VkIndirectCommandsLayoutUsageFlagBitsNVX* {.size: sizeof(cint).} = enum
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
VkIndirectCommandsTokenTypeNVX* {.size: sizeof(cint).} = enum
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1
VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2
VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7
VkObjectEntryUsageFlagBitsNVX* {.size: sizeof(cint).} = enum
VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001
VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002
VkObjectEntryTypeNVX* {.size: sizeof(cint).} = enum
VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0
VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1
VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2
VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3
VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4
VkDeviceGeneratedCommandsFeaturesNVX* = object
sType: VkStructureType
pNext: pointer
computeBindingPointSupport: VkBool32
VkDeviceGeneratedCommandsLimitsNVX* = object
sType: VkStructureType
pNext: pointer
maxIndirectCommandsLayoutTokenCount: uint32
maxObjectEntryCounts: uint32
minSequenceCountBufferOffsetAlignment: uint32
minSequenceIndexBufferOffsetAlignment: uint32
minCommandsTokenBufferOffsetAlignment: uint32
VkIndirectCommandsTokenNVX* = object
tokenType: VkIndirectCommandsTokenTypeNVX
buffer: VkBuffer
offset: VkDeviceSize
VkIndirectCommandsLayoutTokenNVX* = object
tokenType: VkIndirectCommandsTokenTypeNVX
bindingUnit: uint32
dynamicCount: uint32
divisor: uint32
VkIndirectCommandsLayoutCreateInfoNVX* = object
sType: VkStructureType
pNext: pointer
pipelineBindPoint: VkPipelineBindPoint
flags: VkIndirectCommandsLayoutUsageFlagsNVX
tokenCount: uint32
pTokens: ptr VkIndirectCommandsLayoutTokenNVX
VkCmdProcessCommandsInfoNVX* = object
sType: VkStructureType
pNext: pointer
objectTable: VkObjectTableNVX
indirectCommandsLayout: VkIndirectCommandsLayoutNVX
indirectCommandsTokenCount: uint32
pIndirectCommandsTokens: ptr VkIndirectCommandsTokenNVX
maxSequencesCount: uint32
targetCommandBuffer: VkCommandBuffer
sequencesCountBuffer: VkBuffer
sequencesCountOffset: VkDeviceSize
sequencesIndexBuffer: VkBuffer
sequencesIndexOffset: VkDeviceSize
VkCmdReserveSpaceForCommandsInfoNVX* = object
sType: VkStructureType
pNext: pointer
objectTable: VkObjectTableNVX
indirectCommandsLayout: VkIndirectCommandsLayoutNVX
maxSequencesCount: uint32
VkObjectTableCreateInfoNVX* = object
sType: VkStructureType
pNext: pointer
objectCount: uint32
pObjectEntryTypes: ptr VkObjectEntryTypeNVX
pObjectEntryCounts: ptr uint32
pObjectEntryUsageFlags: ptr VkObjectEntryUsageFlagsNVX
maxUniformBuffersPerDescriptor: uint32
maxStorageBuffersPerDescriptor: uint32
maxStorageImagesPerDescriptor: uint32
maxSampledImagesPerDescriptor: uint32
maxPipelineLayouts: uint32
VkObjectTableEntryNVX* = object
theType: VkObjectEntryTypeNVX
flags: VkObjectEntryUsageFlagsNVX
VkObjectTablePipelineEntryNVX* = object
theType: VkObjectEntryTypeNVX
flags: VkObjectEntryUsageFlagsNVX
pipeline: VkPipeline
VkObjectTableDescriptorSetEntryNVX* = object
theType: VkObjectEntryTypeNVX
flags: VkObjectEntryUsageFlagsNVX
pipelineLayout: VkPipelineLayout
descriptorSet: VkDescriptorSet
VkObjectTableVertexBufferEntryNVX* = object
theType: VkObjectEntryTypeNVX
flags: VkObjectEntryUsageFlagsNVX
buffer: VkBuffer
VkObjectTableIndexBufferEntryNVX* = object
theType: VkObjectEntryTypeNVX
flags: VkObjectEntryUsageFlagsNVX
buffer: VkBuffer
indexType: VkIndexType
VkObjectTablePushConstantEntryNVX* = object
theType: VkObjectEntryTypeNVX
flags: VkObjectEntryUsageFlagsNVX
pipelineLayout: VkPipelineLayout
stageFlags: VkShaderStageFlags
PFN_vkCmdProcessCommandsNVX* = proc (
commandBuffer: VkCommandBuffer;
pProcessCommandsInfo: ptr VkCmdProcessCommandsInfoNVX;
): void {.cdecl.}
PFN_vkCmdReserveSpaceForCommandsNVX* = proc (
commandBuffer: VkCommandBuffer;
pReserveSpaceInfo: ptr VkCmdReserveSpaceForCommandsInfoNVX;
): void {.cdecl.}
PFN_vkCreateIndirectCommandsLayoutNVX* = proc (
device: VkDevice;
pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNVX;
): VkResult {.cdecl.}
PFN_vkDestroyIndirectCommandsLayoutNVX* = proc (
device: VkDevice;
indirectCommandsLayout: VkIndirectCommandsLayoutNVX;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkCreateObjectTableNVX* = proc (
device: VkDevice;
pCreateInfo: ptr VkObjectTableCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pObjectTable: ptr VkObjectTableNVX;
): VkResult {.cdecl.}
PFN_vkDestroyObjectTableNVX* = proc (
device: VkDevice;
objectTable: VkObjectTableNVX;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkRegisterObjectsNVX* = proc (
device: VkDevice;
objectTable: VkObjectTableNVX;
objectCount: uint32;
ppObjectTableEntries: ptr VkObjectTableEntryNVX;
pObjectIndices: ptr uint32;
): VkResult {.cdecl.}
PFN_vkUnregisterObjectsNVX* = proc (
device: VkDevice;
objectTable: VkObjectTableNVX;
objectCount: uint32;
pObjectEntryTypes: ptr VkObjectEntryTypeNVX;
pObjectIndices: ptr uint32;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX* = proc (
physicalDevice: VkPhysicalDevice;
pFeatures: ptr VkDeviceGeneratedCommandsFeaturesNVX;
pLimits: ptr VkDeviceGeneratedCommandsLimitsNVX;
): void {.cdecl.}
const
VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION* = 1
VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME*
= "VK_NV_fragment_shader_barycentric"
type
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* = object
sType: VkStructureType
pNext: pointer
fragmentShaderBarycentric: VkBool32
const
VK_KHR_EXTENSION_185_SPEC_VERSION* = 0
VK_KHR_EXTENSION_185_EXTENSION_NAME* = "VK_AMD_extension_185"
VK_KHR_DEVICE_GROUP_SPEC_VERSION* = 3
VK_KHR_DEVICE_GROUP_EXTENSION_NAME* = "VK_KHR_device_group"
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR*
= VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO
VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR*
= VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO
VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR*
= VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO
VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR*
= VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR*
= VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO
type
VkPeerMemoryFeatureFlagsKHR* = VkPeerMemoryFeatureFlags
VkPeerMemoryFeatureFlagBitsKHR* = VkPeerMemoryFeatureFlagBits
const
VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR*
= VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT
VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR*
= VK_PEER_MEMORY_FEATURE_COPY_DST_BIT
VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR*
= VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT
VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR*
= VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
type
VkMemoryAllocateFlagsKHR* = VkMemoryAllocateFlags
VkMemoryAllocateFlagBitsKHR* = VkMemoryAllocateFlagBits
const
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR*
= VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
type
VkMemoryAllocateFlagsInfoKHR* = VkMemoryAllocateFlagsInfo
VkDeviceGroupRenderPassBeginInfoKHR* = VkDeviceGroupRenderPassBeginInfo
VkDeviceGroupCommandBufferBeginInfoKHR*
= VkDeviceGroupCommandBufferBeginInfo
VkDeviceGroupSubmitInfoKHR* = VkDeviceGroupSubmitInfo
VkDeviceGroupBindSparseInfoKHR* = VkDeviceGroupBindSparseInfo
vkGetDeviceGroupPeerMemoryFeaturesKHR*
= PFN_vkGetDeviceGroupPeerMemoryFeatures
vkCmdSetDeviceMaskKHR* = PFN_vkCmdSetDeviceMask
vkCmdDispatchBaseKHR* = PFN_vkCmdDispatchBase
const
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR*
= VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR* = VK_PIPELINE_CREATE_DISPATCH_BASE
VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR* = VK_DEPENDENCY_DEVICE_GROUP_BIT
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR*
= VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR*
= VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO
type
VkBindBufferMemoryDeviceGroupInfoKHR* = VkBindBufferMemoryDeviceGroupInfo
VkBindImageMemoryDeviceGroupInfoKHR* = VkBindImageMemoryDeviceGroupInfo
const
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR*
= VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT
VK_KHR_SURFACE_SPEC_VERSION* = 25
VK_KHR_SURFACE_EXTENSION_NAME* = "VK_KHR_surface"
type
PFN_vkDestroySurfaceKHR* = proc (
instance: VkInstance;
surface: VkSurfaceKHR;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkGetPhysicalDeviceSurfaceSupportKHR* = proc (
physicalDevice: VkPhysicalDevice;
queueFamilyIndex: uint32;
surface: VkSurfaceKHR;
pSupported: ptr VkBool32;
): VkResult {.cdecl.}
VkSurfaceCapabilitiesKHR* = object
minImageCount: uint32
maxImageCount: uint32
currentExtent: VkExtent2D
minImageExtent: VkExtent2D
maxImageExtent: VkExtent2D
maxImageArrayLayers: uint32
supportedTransforms: VkSurfaceTransformFlagsKHR
currentTransform: VkSurfaceTransformFlagBitsKHR
supportedCompositeAlpha: VkCompositeAlphaFlagsKHR
supportedUsageFlags: VkImageUsageFlags
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR* = proc (
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR;
): VkResult {.cdecl.}
VkSurfaceFormatKHR* = object
format: VkFormat
colorSpace: VkColorSpaceKHR
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR* = proc (
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pSurfaceFormatCount: ptr uint32;
pSurfaceFormats: ptr VkSurfaceFormatKHR;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR* = proc (
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pPresentModeCount: ptr uint32;
pPresentModes: ptr VkPresentModeKHR;
): VkResult {.cdecl.}
const
VK_KHR_MAINTENANCE1_SPEC_VERSION* = 2
VK_KHR_MAINTENANCE1_EXTENSION_NAME* = "VK_KHR_maintenance1"
VK_ERROR_OUT_OF_POOL_MEMORY_KHR* = VK_ERROR_OUT_OF_POOL_MEMORY
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR*
= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR*
= VK_FORMAT_FEATURE_TRANSFER_DST_BIT
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR*
= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT
type
VkCommandPoolTrimFlagsKHR* = VkCommandPoolTrimFlags
vkTrimCommandPoolKHR* = PFN_vkTrimCommandPool
const
VK_KHR_8BIT_STORAGE_SPEC_VERSION* = 1
VK_KHR_8BIT_STORAGE_EXTENSION_NAME* = "VK_KHR_8bit_storage"
type
VkPhysicalDevice8BitStorageFeaturesKHR* = object
sType: VkStructureType
pNext: pointer
storageBuffer8BitAccess: VkBool32
uniformAndStorageBuffer8BitAccess: VkBool32
storagePushConstant8: VkBool32
const
VK_AMD_EXTENSION_143_SPEC_VERSION* = 0
VK_AMD_EXTENSION_143_EXTENSION_NAME* = "VK_AMD_extension_143"
VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION* = 2
VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME*
= "VK_NV_device_diagnostic_checkpoints"
type
VkQueueFamilyCheckpointPropertiesNV* = object
sType: VkStructureType
pNext: pointer
checkpointExecutionStageMask: VkPipelineStageFlags
VkCheckpointDataNV* = object
sType: VkStructureType
pNext: pointer
stage: VkPipelineStageFlagBits
pCheckpointMarker: pointer
PFN_vkCmdSetCheckpointNV* = proc (
commandBuffer: VkCommandBuffer;
pCheckpointMarker: pointer;
): void {.cdecl.}
PFN_vkGetQueueCheckpointDataNV* = proc (
queue: VkQueue;
pCheckpointDataCount: ptr uint32;
pCheckpointData: ptr VkCheckpointDataNV;
): void {.cdecl.}
const
VK_GOOGLE_EXTENSION_193_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_193_EXTENSION_NAME* = "VK_GOOGLE_extension_193"
VK_KHR_EXTENSION_215_SPEC_VERSION* = 0
VK_KHR_EXTENSION_215_EXTENSION_NAME* = "VK_KHR_extension_215"
VK_KHR_EXTENSION_208_SPEC_VERSION* = 0
VK_KHR_EXTENSION_208_EXTENSION_NAME* = "VK_KHR_extension_208"
VK_KHR_MAINTENANCE3_SPEC_VERSION* = 1
VK_KHR_MAINTENANCE3_EXTENSION_NAME* = "VK_KHR_maintenance3"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR*
= VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT
type
VkPhysicalDeviceMaintenance3PropertiesKHR*
= VkPhysicalDeviceMaintenance3Properties
VkDescriptorSetLayoutSupportKHR* = VkDescriptorSetLayoutSupport
vkGetDescriptorSetLayoutSupportKHR* = PFN_vkGetDescriptorSetLayoutSupport
const
VK_KHR_EXTENSION_217_SPEC_VERSION* = 0
VK_KHR_EXTENSION_217_EXTENSION_NAME* = "VK_KHR_extension_217"
VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION* = 1
VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME* = "VK_EXT_post_depth_coverage"
VK_NV_EXTENSION_104_SPEC_VERSION* = 0
VK_NV_EXTENSION_104_EXTENSION_NAME* = "VK_NV_extension_104"
VK_NVX_RAYTRACING_SPEC_VERSION* = 1
VK_NVX_RAYTRACING_EXTENSION_NAME* = "VK_NVX_raytracing"
type
VkRaytracingPipelineCreateInfoNVX* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineCreateFlags
stageCount: uint32
pStages: ptr VkPipelineShaderStageCreateInfo
pGroupNumbers: ptr uint32
maxRecursionDepth: uint32
layout: VkPipelineLayout
basePipelineHandle: VkPipeline
basePipelineIndex: int32
VkGeometryTrianglesNVX* = object
sType: VkStructureType
pNext: pointer
vertexData: VkBuffer
vertexOffset: VkDeviceSize
vertexCount: uint32
vertexStride: VkDeviceSize
vertexFormat: VkFormat
indexData: VkBuffer
indexOffset: VkDeviceSize
indexCount: uint32
indexType: VkIndexType
transformData: VkBuffer
transformOffset: VkDeviceSize
VkGeometryAABBNVX* = object
sType: VkStructureType
pNext: pointer
aabbData: VkBuffer
numAABBs: uint32
stride: uint32
offset: VkDeviceSize
VkGeometryDataNVX* = object
triangles: VkGeometryTrianglesNVX
aabbs: VkGeometryAABBNVX
VkGeometryTypeNVX* {.size: sizeof(cint).} = enum
VK_GEOMETRY_TYPE_TRIANGLES_NVX = 0
VK_GEOMETRY_TYPE_AABBS_NVX = 1
VkGeometryFlagsNVX* = VkFlags
VkGeometryNVX* = object
sType: VkStructureType
pNext: pointer
geometryType: VkGeometryTypeNVX
geometry: VkGeometryDataNVX
flags: VkGeometryFlagsNVX
VkGeometryInstanceFlagsNVX* = VkFlags
VkGeometryFlagBitsNVX* {.size: sizeof(cint).} = enum
VK_GEOMETRY_OPAQUE_BIT_NVX = 0x00000001
VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX = 0x00000002
VkGeometryInstanceFlagBitsNVX* {.size: sizeof(cint).} = enum
VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX = 0x00000001
VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX = 0x00000002
VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX = 0x00000004
VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX = 0x00000008
VkAccelerationStructureTypeNVX* {.size: sizeof(cint).} = enum
VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX = 0
VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX = 1
VkBuildAccelerationStructureFlagsNVX* = VkFlags
VkAccelerationStructureCreateInfoNVX* = object
sType: VkStructureType
pNext: pointer
theType: VkAccelerationStructureTypeNVX
flags: VkBuildAccelerationStructureFlagsNVX
compactedSize: VkDeviceSize
instanceCount: uint32
geometryCount: uint32
pGeometries: ptr VkGeometryNVX
VkAccelerationStructureNVX* = VkNonDispatchableHandle
VkBuildAccelerationStructureFlagBitsNVX* {.size: sizeof(cint).} = enum
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX = 0x00000001
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX = 0x00000002
VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX = 0x00000004
VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX = 0x00000008
VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX = 0x00000010
VkCopyAccelerationStructureModeNVX* {.size: sizeof(cint).} = enum
VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX = 0
VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX = 1
VkBindAccelerationStructureMemoryInfoNVX* = object
sType: VkStructureType
pNext: pointer
accelerationStructure: VkAccelerationStructureNVX
memory: VkDeviceMemory
memoryOffset: VkDeviceSize
deviceIndexCount: uint32
pDeviceIndices: ptr uint32
VkDescriptorAccelerationStructureInfoNVX* = object
sType: VkStructureType
pNext: pointer
accelerationStructureCount: uint32
pAccelerationStructures: ptr VkAccelerationStructureNVX
VkAccelerationStructureMemoryRequirementsInfoNVX* = object
sType: VkStructureType
pNext: pointer
accelerationStructure: VkAccelerationStructureNVX
VkPhysicalDeviceRaytracingPropertiesNVX* = object
sType: VkStructureType
pNext: pointer
shaderHeaderSize: uint32
maxRecursionDepth: uint32
maxGeometryCount: uint32
PFN_vkCreateAccelerationStructureNVX* = proc (
device: VkDevice;
pCreateInfo: ptr VkAccelerationStructureCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pAccelerationStructure: ptr VkAccelerationStructureNVX;
): VkResult {.cdecl.}
PFN_vkDestroyAccelerationStructureNVX* = proc (
device: VkDevice;
accelerationStructure: VkAccelerationStructureNVX;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkGetAccelerationStructureMemoryRequirementsNVX* = proc (
device: VkDevice;
pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNVX;
pMemoryRequirements: ptr VkMemoryRequirements2KHR;
): void {.cdecl.}
PFN_vkGetAccelerationStructureScratchMemoryRequirementsNVX* = proc (
device: VkDevice;
pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNVX;
pMemoryRequirements: ptr VkMemoryRequirements2KHR;
): void {.cdecl.}
PFN_vkBindAccelerationStructureMemoryNVX* = proc (
device: VkDevice;
bindInfoCount: uint32;
pBindInfos: ptr VkBindAccelerationStructureMemoryInfoNVX;
): VkResult {.cdecl.}
PFN_vkCmdBuildAccelerationStructureNVX* = proc (
cmdBuf: VkCommandBuffer;
theType: VkAccelerationStructureTypeNVX;
instanceCount: uint32;
instanceData: VkBuffer;
instanceOffset: VkDeviceSize;
geometryCount: uint32;
pGeometries: ptr VkGeometryNVX;
flags: VkBuildAccelerationStructureFlagsNVX;
update: VkBool32;
dst: VkAccelerationStructureNVX;
src: VkAccelerationStructureNVX;
scratch: VkBuffer;
scratchOffset: VkDeviceSize;
): void {.cdecl.}
PFN_vkCmdCopyAccelerationStructureNVX* = proc (
cmdBuf: VkCommandBuffer;
dst: VkAccelerationStructureNVX;
src: VkAccelerationStructureNVX;
mode: VkCopyAccelerationStructureModeNVX;
): void {.cdecl.}
PFN_vkCmdTraceRaysNVX* = proc (
cmdBuf: VkCommandBuffer;
raygenShaderBindingTableBuffer: VkBuffer;
raygenShaderBindingOffset: VkDeviceSize;
missShaderBindingTableBuffer: VkBuffer;
missShaderBindingOffset: VkDeviceSize;
missShaderBindingStride: VkDeviceSize;
hitShaderBindingTableBuffer: VkBuffer;
hitShaderBindingOffset: VkDeviceSize;
hitShaderBindingStride: VkDeviceSize;
width: uint32;
height: uint32;
): void {.cdecl.}
PFN_vkCreateRaytracingPipelinesNVX* = proc (
device: VkDevice;
pipelineCache: VkPipelineCache;
createInfoCount: uint32;
pCreateInfos: ptr VkRaytracingPipelineCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pPipelines: ptr VkPipeline;
): VkResult {.cdecl.}
PFN_vkGetRaytracingShaderHandlesNVX* = proc (
device: VkDevice;
pipeline: VkPipeline;
firstGroup: uint32;
groupCount: uint32;
dataSize: csize;
pData: pointer;
): VkResult {.cdecl.}
PFN_vkGetAccelerationStructureHandleNVX* = proc (
device: VkDevice;
accelerationStructure: VkAccelerationStructureNVX;
dataSize: csize;
pData: pointer;
): VkResult {.cdecl.}
PFN_vkCmdWriteAccelerationStructurePropertiesNVX* = proc (
cmdBuf: VkCommandBuffer;
accelerationStructure: VkAccelerationStructureNVX;
queryType: VkQueryType;
queryPool: VkQueryPool;
query: uint32;
): void {.cdecl.}
PFN_vkCompileDeferredNVX* = proc (
device: VkDevice;
pipeline: VkPipeline;
shader: uint32;
): VkResult {.cdecl.}
const
VK_IMG_EXTENSION_108_SPEC_VERSION* = 0
VK_IMG_EXTENSION_108_EXTENSION_NAME* = "VK_IMG_extension_108"
VK_KHR_VARIABLE_POINTERS_SPEC_VERSION* = 1
VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME* = "VK_KHR_variable_pointers"
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES
type
VkPhysicalDeviceVariablePointerFeaturesKHR*
= VkPhysicalDeviceVariablePointerFeatures
const
VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION* = 1
VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME*
= "VK_EXT_shader_stencil_export"
VK_KHR_EXTENSION_190_SPEC_VERSION* = 0
VK_KHR_EXTENSION_190_EXTENSION_NAME* = "VK_AMD_extension_190"
VK_KHR_EXTENSION_210_SPEC_VERSION* = 0
VK_KHR_EXTENSION_210_EXTENSION_NAME* = "VK_KHR_extension_210"
VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION* = 1
VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME* = "VK_KHR_image_format_list"
type
VkImageFormatListCreateInfoKHR* = object
sType: VkStructureType
pNext: pointer
viewFormatCount: uint32
pViewFormats: ptr VkFormat
const
VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION* = 1
VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME*
= "VK_NV_framebuffer_mixed_samples"
type
VkPipelineCoverageModulationStateCreateFlagsNV* = VkFlags
VkCoverageModulationModeNV* {.size: sizeof(cint).} = enum
VK_COVERAGE_MODULATION_MODE_NONE_NV = 0
VK_COVERAGE_MODULATION_MODE_RGB_NV = 1
VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2
VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3
VkPipelineCoverageModulationStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineCoverageModulationStateCreateFlagsNV
coverageModulationMode: VkCoverageModulationModeNV
coverageModulationTableEnable: VkBool32
coverageModulationTableCount: uint32
pCoverageModulationTable: ptr cfloat
const
VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION* = 2
VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME* = "VK_EXT_descriptor_indexing"
type
VkDescriptorPoolCreateFlagBits* {.size: sizeof(cint).} = enum
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001
VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002
VkDescriptorBindingFlagsEXT* = VkFlags
VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
bindingCount: uint32
pBindingFlags: ptr VkDescriptorBindingFlagsEXT
VkPhysicalDeviceDescriptorIndexingFeaturesEXT* = object
sType: VkStructureType
pNext: pointer
shaderInputAttachmentArrayDynamicIndexing: VkBool32
shaderUniformTexelBufferArrayDynamicIndexing: VkBool32
shaderStorageTexelBufferArrayDynamicIndexing: VkBool32
shaderUniformBufferArrayNonUniformIndexing: VkBool32
shaderSampledImageArrayNonUniformIndexing: VkBool32
shaderStorageBufferArrayNonUniformIndexing: VkBool32
shaderStorageImageArrayNonUniformIndexing: VkBool32
shaderInputAttachmentArrayNonUniformIndexing: VkBool32
shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32
shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32
descriptorBindingUniformBufferUpdateAfterBind: VkBool32
descriptorBindingSampledImageUpdateAfterBind: VkBool32
descriptorBindingStorageImageUpdateAfterBind: VkBool32
descriptorBindingStorageBufferUpdateAfterBind: VkBool32
descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32
descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32
descriptorBindingUpdateUnusedWhilePending: VkBool32
descriptorBindingPartiallyBound: VkBool32
descriptorBindingVariableDescriptorCount: VkBool32
runtimeDescriptorArray: VkBool32
VkPhysicalDeviceDescriptorIndexingPropertiesEXT* = object
sType: VkStructureType
pNext: pointer
maxUpdateAfterBindDescriptorsInAllPools: uint32
shaderUniformBufferArrayNonUniformIndexingNative: VkBool32
shaderSampledImageArrayNonUniformIndexingNative: VkBool32
shaderStorageBufferArrayNonUniformIndexingNative: VkBool32
shaderStorageImageArrayNonUniformIndexingNative: VkBool32
shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32
robustBufferAccessUpdateAfterBind: VkBool32
quadDivergentImplicitLod: VkBool32
maxPerStageDescriptorUpdateAfterBindSamplers: uint32
maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32
maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32
maxPerStageDescriptorUpdateAfterBindSampledImages: uint32
maxPerStageDescriptorUpdateAfterBindStorageImages: uint32
maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32
maxPerStageUpdateAfterBindResources: uint32
maxDescriptorSetUpdateAfterBindSamplers: uint32
maxDescriptorSetUpdateAfterBindUniformBuffers: uint32
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32
maxDescriptorSetUpdateAfterBindStorageBuffers: uint32
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32
maxDescriptorSetUpdateAfterBindSampledImages: uint32
maxDescriptorSetUpdateAfterBindStorageImages: uint32
maxDescriptorSetUpdateAfterBindInputAttachments: uint32
VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* = object
sType: VkStructureType
pNext: pointer
descriptorSetCount: uint32
pDescriptorCounts: ptr uint32
VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* = object
sType: VkStructureType
pNext: pointer
maxVariableDescriptorCount: uint32
const
VK_AMD_EXTENSION_142_SPEC_VERSION* = 0
VK_AMD_EXTENSION_142_EXTENSION_NAME* = "VK_AMD_extension_142"
VK_AMD_EXTENSION_135_SPEC_VERSION* = 0
VK_AMD_EXTENSION_135_EXTENSION_NAME* = "VK_AMD_extension_135"
VK_NV_GLSL_SHADER_SPEC_VERSION* = 1
VK_NV_GLSL_SHADER_EXTENSION_NAME* = "VK_NV_glsl_shader"
VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION* = 1
VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME*
= "VK_AMD_mixed_attachment_samples"
VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION* = 1
VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME*
= "VK_KHR_get_surface_capabilities2"
type
VkPhysicalDeviceSurfaceInfo2KHR* = object
sType: VkStructureType
pNext: pointer
surface: VkSurfaceKHR
VkSurfaceCapabilities2KHR* = object
sType: VkStructureType
pNext: pointer
surfaceCapabilities: VkSurfaceCapabilitiesKHR
VkSurfaceFormat2KHR* = object
sType: VkStructureType
pNext: pointer
surfaceFormat: VkSurfaceFormatKHR
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR* = proc (
physicalDevice: VkPhysicalDevice;
pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR;
pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR;
): VkResult {.cdecl.}
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR* = proc (
physicalDevice: VkPhysicalDevice;
pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR;
pSurfaceFormatCount: ptr uint32;
pSurfaceFormats: ptr VkSurfaceFormat2KHR;
): VkResult {.cdecl.}
const
VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION* = 1
VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME*
= "VK_NV_external_memory_capabilities"
type
VkExternalMemoryHandleTypeFlagsNV* = VkFlags
VkExternalMemoryHandleTypeFlagBitsNV* {.size: sizeof(cint).} = enum
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
VkExternalMemoryFeatureFlagsNV* = VkFlags
VkExternalMemoryFeatureFlagBitsNV* {.size: sizeof(cint).} = enum
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
VkExternalImageFormatPropertiesNV* = object
imageFormatProperties: VkImageFormatProperties
externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV
exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV
compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV* = proc (
physicalDevice: VkPhysicalDevice;
format: VkFormat;
theType: VkImageType;
tiling: VkImageTiling;
usage: VkImageUsageFlags;
flags: VkImageCreateFlags;
externalHandleType: VkExternalMemoryHandleTypeFlagsNV;
pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV;
): VkResult {.cdecl.}
const
VK_ARM_EXTENSION_01_SPEC_VERSION* = 0
VK_ARM_EXTENSION_01_EXTENSION_NAME* = "VK_ARM_extension_01"
VK_KHR_EXTENSION_211_SPEC_VERSION* = 0
VK_KHR_EXTENSION_211_EXTENSION_NAME* = "VK_KHR_extension_211"
VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION* = 1
VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME*
= "VK_AMD_gpu_shader_half_float"
VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION* = 1
VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME*
= "VK_AMD_negative_viewport_height"
VK_KHR_EXTENSION_188_SPEC_VERSION* = 0
VK_KHR_EXTENSION_188_EXTENSION_NAME* = "VK_AMD_extension_188"
VK_GOOGLE_EXTENSION_194_SPEC_VERSION* = 0
VK_GOOGLE_EXTENSION_194_EXTENSION_NAME* = "VK_GOOGLE_extension_194"
VK_NV_EXTENSION_101_SPEC_VERSION* = 0
VK_NV_EXTENSION_101_EXTENSION_NAME* = "VK_NV_extension_101"
VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION* = 1
VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME*
= "VK_KHR_shared_presentable_image"
type
VkSharedPresentSurfaceCapabilitiesKHR* = object
sType: VkStructureType
pNext: pointer
sharedPresentSupportedUsageFlags: VkImageUsageFlags
PFN_vkGetSwapchainStatusKHR* = proc (
device: VkDevice;
swapchain: VkSwapchainKHR;
): VkResult {.cdecl.}
const
VK_KHR_MULTIVIEW_SPEC_VERSION* = 1
VK_KHR_MULTIVIEW_EXTENSION_NAME* = "VK_KHR_multiview"
VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR*
= VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR*
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES
VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR* = VK_DEPENDENCY_VIEW_LOCAL_BIT
type
VkRenderPassMultiviewCreateInfoKHR* = VkRenderPassMultiviewCreateInfo
VkPhysicalDeviceMultiviewFeaturesKHR* = VkPhysicalDeviceMultiviewFeatures
VkPhysicalDeviceMultiviewPropertiesKHR*
= VkPhysicalDeviceMultiviewProperties
const
VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION* = 1
VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME* = "VK_NV_viewport_swizzle"
type
VkViewportCoordinateSwizzleNV* {.size: sizeof(cint).} = enum
VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0
VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1
VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2
VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3
VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4
VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5
VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6
VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7
VkViewportSwizzleNV* = object
x: VkViewportCoordinateSwizzleNV
y: VkViewportCoordinateSwizzleNV
z: VkViewportCoordinateSwizzleNV
w: VkViewportCoordinateSwizzleNV
VkPipelineViewportSwizzleStateCreateFlagsNV* = VkFlags
VkPipelineViewportSwizzleStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineViewportSwizzleStateCreateFlagsNV
viewportCount: uint32
pViewportSwizzles: ptr VkViewportSwizzleNV
const
VK_IMG_EXTENSION_107_SPEC_VERSION* = 0
VK_IMG_EXTENSION_107_EXTENSION_NAME* = "VK_IMG_extension_107"
VK_AMD_EXTENSION_32_SPEC_VERSION* = 0
VK_AMD_EXTENSION_32_EXTENSION_NAME* = "VK_AMD_extension_32"
VK_AMD_EXTENSION_40_SPEC_VERSION* = 0
VK_AMD_EXTENSION_40_EXTENSION_NAME* = "VK_AMD_extension_40"
VK_KHR_EXTENSION_182_SPEC_VERSION* = 0
VK_KHR_EXTENSION_182_EXTENSION_NAME* = "VK_AMD_extension_182"
VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION* = 1
VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME*
= "VK_NV_geometry_shader_passthrough"
VK_NVX_EXTENSION_29_SPEC_VERSION* = 0
VK_NVX_EXTENSION_29_EXTENSION_NAME* = "VK_NVX_extension_29"
VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION* = 9
VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME* = "VK_KHR_display_swapchain"
type
VkDisplayPresentInfoKHR* = object
sType: VkStructureType
pNext: pointer
srcRect: VkRect2D
dstRect: VkRect2D
persistent: VkBool32
PFN_vkCreateSharedSwapchainsKHR* = proc (
device: VkDevice;
swapchainCount: uint32;
pCreateInfos: ptr VkSwapchainCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pSwapchains: ptr VkSwapchainKHR;
): VkResult {.cdecl.}
const
VK_KHR_EXTENSION_189_SPEC_VERSION* = 0
VK_KHR_EXTENSION_189_EXTENSION_NAME* = "VK_AMD_extension_189"
VK_KHR_EXTENSION_83_SPEC_VERSION* = 0
VK_KHR_EXTENSION_83_EXTENSION_NAME* = "VK_KHR_extension_83"
VK_EXT_HDR_METADATA_SPEC_VERSION* = 1
VK_EXT_HDR_METADATA_EXTENSION_NAME* = "VK_EXT_hdr_metadata"
type
VkXYColorEXT* = object
x: cfloat
y: cfloat
VkHdrMetadataEXT* = object
sType: VkStructureType
pNext: pointer
displayPrimaryRed: VkXYColorEXT
displayPrimaryGreen: VkXYColorEXT
displayPrimaryBlue: VkXYColorEXT
whitePoint: VkXYColorEXT
maxLuminance: cfloat
minLuminance: cfloat
maxContentLightLevel: cfloat
maxFrameAverageLightLevel: cfloat
PFN_vkSetHdrMetadataEXT* = proc (
device: VkDevice;
swapchainCount: uint32;
pSwapchains: ptr VkSwapchainKHR;
pMetadata: ptr VkHdrMetadataEXT;
): void {.cdecl.}
const
VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION* = 1
VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME* = "VK_NV_clip_space_w_scaling"
type
VkViewportWScalingNV* = object
xcoeff: cfloat
ycoeff: cfloat
VkPipelineViewportWScalingStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
viewportWScalingEnable: VkBool32
viewportCount: uint32
pViewportWScalings: ptr VkViewportWScalingNV
PFN_vkCmdSetViewportWScalingNV* = proc (
commandBuffer: VkCommandBuffer;
firstViewport: uint32;
viewportCount: uint32;
pViewportWScalings: ptr VkViewportWScalingNV;
): void {.cdecl.}
const
VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION* = 1
VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME*
= "VK_EXT_external_memory_dma_buf"
VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION* = 1
VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME* = "VK_NV_viewport_array2"
VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION* = 1
VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME*
= "VK_EXT_depth_range_unrestricted"
VK_NV_EXTERNAL_MEMORY_SPEC_VERSION* = 1
VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME* = "VK_NV_external_memory"
type
VkExternalMemoryImageCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalMemoryHandleTypeFlagsNV
VkExportMemoryAllocateInfoNV* = object
sType: VkStructureType
pNext: pointer
handleTypes: VkExternalMemoryHandleTypeFlagsNV
const
VK_KHR_EXTENSION_200_SPEC_VERSION* = 0
VK_KHR_EXTENSION_200_EXTENSION_NAME* = "VK_KHR_extension_200"
VK_EXT_DEBUG_UTILS_SPEC_VERSION* = 1
VK_EXT_DEBUG_UTILS_EXTENSION_NAME* = "VK_EXT_debug_utils"
type
VkDebugUtilsObjectNameInfoEXT* = object
sType: VkStructureType
pNext: pointer
objectType: VkObjectType
objectHandle: uint64
pObjectName: cstring
VkDebugUtilsObjectTagInfoEXT* = object
sType: VkStructureType
pNext: pointer
objectType: VkObjectType
objectHandle: uint64
tagName: uint64
tagSize: csize
pTag: pointer
VkDebugUtilsLabelEXT* = object
sType: VkStructureType
pNext: pointer
pLabelName: cstring
color: array[4, cfloat]
VkDebugUtilsMessengerCallbackDataFlagsEXT* = VkFlags
VkDebugUtilsMessengerCallbackDataEXT* = object
sType: VkStructureType
pNext: pointer
flags: VkDebugUtilsMessengerCallbackDataFlagsEXT
pMessageIdName: cstring
messageIdNumber: int32
pMessage: cstring
queueLabelCount: uint32
pQueueLabels: ptr VkDebugUtilsLabelEXT
cmdBufLabelCount: uint32
pCmdBufLabels: ptr VkDebugUtilsLabelEXT
objectCount: uint32
pObjects: ptr VkDebugUtilsObjectNameInfoEXT
VkDebugUtilsMessengerCreateFlagsEXT* = VkFlags
VkDebugUtilsMessageSeverityFlagsEXT* = VkFlags
VkDebugUtilsMessageTypeFlagsEXT* = VkFlags
VkDebugUtilsMessageSeverityFlagBitsEXT* {.size: sizeof(cint).} = enum
VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001
VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000
PFN_vkDebugUtilsMessengerCallbackEXT* = proc (
messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT;
messageType: VkDebugUtilsMessageTypeFlagsEXT;
pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT;
pUserData: pointer;
): VkBool32 {.cdecl.}
VkDebugUtilsMessengerCreateInfoEXT* = object
sType: VkStructureType
pNext: pointer
flags: VkDebugUtilsMessengerCreateFlagsEXT
messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT
messageType: VkDebugUtilsMessageTypeFlagsEXT
pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT
pUserData: pointer
PFN_vkSetDebugUtilsObjectNameEXT* = proc (
device: VkDevice;
pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT;
): VkResult {.cdecl.}
PFN_vkSetDebugUtilsObjectTagEXT* = proc (
device: VkDevice;
pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT;
): VkResult {.cdecl.}
PFN_vkQueueBeginDebugUtilsLabelEXT* = proc (
queue: VkQueue;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl.}
PFN_vkQueueEndDebugUtilsLabelEXT* = proc (
queue: VkQueue;
): void {.cdecl.}
PFN_vkQueueInsertDebugUtilsLabelEXT* = proc (
queue: VkQueue;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl.}
PFN_vkCmdBeginDebugUtilsLabelEXT* = proc (
commandBuffer: VkCommandBuffer;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl.}
PFN_vkCmdEndDebugUtilsLabelEXT* = proc (
commandBuffer: VkCommandBuffer;
): void {.cdecl.}
PFN_vkCmdInsertDebugUtilsLabelEXT* = proc (
commandBuffer: VkCommandBuffer;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl.}
VkDebugUtilsMessengerEXT* = VkNonDispatchableHandle
PFN_vkCreateDebugUtilsMessengerEXT* = proc (
instance: VkInstance;
pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pMessenger: ptr VkDebugUtilsMessengerEXT;
): VkResult {.cdecl.}
PFN_vkDestroyDebugUtilsMessengerEXT* = proc (
instance: VkInstance;
messenger: VkDebugUtilsMessengerEXT;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl.}
PFN_vkSubmitDebugUtilsMessageEXT* = proc (
instance: VkInstance;
messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT;
messageTypes: VkDebugUtilsMessageTypeFlagsEXT;
pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT;
): void {.cdecl.}
const
VK_NV_MESH_SHADER_SPEC_VERSION* = 1
VK_NV_MESH_SHADER_EXTENSION_NAME* = "VK_NV_mesh_shader"
type
PFN_vkCmdDrawMeshTasksNV* = proc (
commandBuffer: VkCommandBuffer;
taskCount: uint32;
firstTask: uint32;
): void {.cdecl.}
PFN_vkCmdDrawMeshTasksIndirectNV* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
drawCount: uint32;
stride: uint32;
): void {.cdecl.}
PFN_vkCmdDrawMeshTasksIndirectCountNV* = proc (
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl.}
VkPhysicalDeviceMeshShaderFeaturesNV* = object
sType: VkStructureType
pNext: pointer
taskShader: VkBool32
meshShader: VkBool32
VkPhysicalDeviceMeshShaderPropertiesNV* = object
sType: VkStructureType
pNext: pointer
maxDrawMeshTasksCount: uint32
maxTaskWorkGroupInvocations: uint32
maxTaskWorkGroupSize: array[3, uint32]
maxTaskTotalMemorySize: uint32
maxTaskOutputCount: uint32
maxMeshWorkGroupInvocations: uint32
maxMeshWorkGroupSize: array[3, uint32]
maxMeshTotalMemorySize: uint32
maxMeshOutputVertices: uint32
maxMeshOutputPrimitives: uint32
maxMeshMultiviewViewCount: uint32
meshOutputPerVertexGranularity: uint32
meshOutputPerPrimitiveGranularity: uint32
VkDrawMeshTasksIndirectCommandNV* = object
taskCount: uint32
firstTask: uint32
const
VK_QCOM_extension_171_SPEC_VERSION* = 0
VK_QCOM_extension_171_EXTENSION_NAME* = "VK_QCOM_extension_171"
VK_ARM_EXTENSION_198_SPEC_VERSION* = 0
VK_ARM_EXTENSION_198_EXTENSION_NAME* = "VK_EXT_extension_198"
VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION* = 1
VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME*
= "VK_NVX_multiview_per_view_attributes"
type
VkSubpassDescriptionFlagBits* {.size: sizeof(cint).} = enum
VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001
VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* = object
sType: VkStructureType
pNext: pointer
perViewPositionAllComponents: VkBool32
const
VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION* = 3
VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME*
= "VK_EXT_swapchain_colorspace"
VK_KHR_EXTENSION_216_SPEC_VERSION* = 0
VK_KHR_EXTENSION_216_EXTENSION_NAME* = "VK_KHR_extension_216"
VK_AMD_EXTENSION_39_SPEC_VERSION* = 0
VK_AMD_EXTENSION_39_EXTENSION_NAME* = "VK_AMD_extension_39"
VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION* = 1
VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME*
= "VK_NV_fragment_coverage_to_color"
type
VkPipelineCoverageToColorStateCreateFlagsNV* = VkFlags
VkPipelineCoverageToColorStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
flags: VkPipelineCoverageToColorStateCreateFlagsNV
coverageToColorEnable: VkBool32
coverageToColorLocation: uint32
const
VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION* = 3
VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME* = "VK_NV_shading_rate_image"
type
VkShadingRatePaletteEntryNV* {.size: sizeof(cint).} = enum
VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0
VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1
VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2
VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3
VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10
VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11
VkShadingRatePaletteNV* = object
shadingRatePaletteEntryCount: uint32
pShadingRatePaletteEntries: ptr VkShadingRatePaletteEntryNV
VkPipelineViewportShadingRateImageStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
shadingRateImageEnable: VkBool32
viewportCount: uint32
pShadingRatePalettes: ptr VkShadingRatePaletteNV
VkPhysicalDeviceShadingRateImageFeaturesNV* = object
sType: VkStructureType
pNext: pointer
shadingRateImage: VkBool32
shadingRateCoarseSampleOrder: VkBool32
VkPhysicalDeviceShadingRateImagePropertiesNV* = object
sType: VkStructureType
pNext: pointer
shadingRateTexelSize: VkExtent2D
shadingRatePaletteSize: uint32
shadingRateMaxCoarseSamples: uint32
VkCoarseSampleLocationNV* = object
pixelX: uint32
pixelY: uint32
sample: uint32
VkCoarseSampleOrderCustomNV* = object
shadingRate: VkShadingRatePaletteEntryNV
sampleCount: uint32
sampleLocationCount: uint32
pSampleLocations: ptr VkCoarseSampleLocationNV
VkCoarseSampleOrderTypeNV* {.size: sizeof(cint).} = enum
VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0
VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1
VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2
VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* = object
sType: VkStructureType
pNext: pointer
sampleOrderType: VkCoarseSampleOrderTypeNV
customSampleOrderCount: uint32
pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV
PFN_vkCmdBindShadingRateImageNV* = proc (
commandBuffer: VkCommandBuffer;
imageView: VkImageView;
imageLayout: VkImageLayout;
): void {.cdecl.}
PFN_vkCmdSetViewportShadingRatePaletteNV* = proc (
commandBuffer: VkCommandBuffer;
firstViewport: uint32;
viewportCount: uint32;
pShadingRatePalettes: ptr VkShadingRatePaletteNV;
): void {.cdecl.}
PFN_vkCmdSetCoarseSampleOrderNV* = proc (
commandBuffer: VkCommandBuffer;
sampleOrderType: VkCoarseSampleOrderTypeNV;
customSampleOrderCount: uint32;
pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV;
): void {.cdecl.}
const
VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION* = 1
VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME* = "VK_KHR_external_memory_fd"
type
VkImportMemoryFdInfoKHR* = object
sType: VkStructureType
pNext: pointer
handleType: VkExternalMemoryHandleTypeFlagBits
fd: int
VkMemoryFdPropertiesKHR* = object
sType: VkStructureType
pNext: pointer
memoryTypeBits: uint32
VkMemoryGetFdInfoKHR* = object
sType: VkStructureType
pNext: pointer
memory: VkDeviceMemory
handleType: VkExternalMemoryHandleTypeFlagBits
PFN_vkGetMemoryFdKHR* = proc (
device: VkDevice;
pGetFdInfo: ptr VkMemoryGetFdInfoKHR;
pFd: ptr int;
): VkResult {.cdecl.}
PFN_vkGetMemoryFdPropertiesKHR* = proc (
device: VkDevice;
handleType: VkExternalMemoryHandleTypeFlagBits;
fd: int;
pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR;
): VkResult {.cdecl.}
const
VK_NV_EXTENSION_103_SPEC_VERSION* = 0
VK_NV_EXTENSION_103_EXTENSION_NAME* = "VK_NV_extension_103"
when not defined(VK_NO_PROTOTYPES):
proc vkCreateInstance*(
pCreateInfo: ptr VkInstanceCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pInstance: ptr VkInstance;
): VkResult {.cdecl, importc.}
proc vkDestroyInstance*(
instance: VkInstance;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkEnumeratePhysicalDevices*(
instance: VkInstance;
pPhysicalDeviceCount: ptr uint32;
pPhysicalDevices: ptr VkPhysicalDevice;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceFeatures*(
physicalDevice: VkPhysicalDevice;
pFeatures: ptr VkPhysicalDeviceFeatures;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceFormatProperties*(
physicalDevice: VkPhysicalDevice;
format: VkFormat;
pFormatProperties: ptr VkFormatProperties;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceImageFormatProperties*(
physicalDevice: VkPhysicalDevice;
format: VkFormat;
theType: VkImageType;
tiling: VkImageTiling;
usage: VkImageUsageFlags;
flags: VkImageCreateFlags;
pImageFormatProperties: ptr VkImageFormatProperties;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceProperties*(
physicalDevice: VkPhysicalDevice;
pProperties: ptr VkPhysicalDeviceProperties;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceQueueFamilyProperties*(
physicalDevice: VkPhysicalDevice;
pQueueFamilyPropertyCount: ptr uint32;
pQueueFamilyProperties: ptr VkQueueFamilyProperties;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceMemoryProperties*(
physicalDevice: VkPhysicalDevice;
pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties;
): void {.cdecl, importc.}
proc vkGetInstanceProcAddr*(
instance: VkInstance;
pName: cstring;
): PFN_vkVoidFunction {.cdecl, importc.}
proc vkGetDeviceProcAddr*(
device: VkDevice;
pName: cstring;
): PFN_vkVoidFunction {.cdecl, importc.}
proc vkCreateDevice*(
physicalDevice: VkPhysicalDevice;
pCreateInfo: ptr VkDeviceCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pDevice: ptr VkDevice;
): VkResult {.cdecl, importc.}
proc vkDestroyDevice*(
device: VkDevice;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkEnumerateInstanceExtensionProperties*(
pLayerName: cstring;
pPropertyCount: ptr uint32;
pProperties: ptr VkExtensionProperties;
): VkResult {.cdecl, importc.}
proc vkEnumerateDeviceExtensionProperties*(
physicalDevice: VkPhysicalDevice;
pLayerName: cstring;
pPropertyCount: ptr uint32;
pProperties: ptr VkExtensionProperties;
): VkResult {.cdecl, importc.}
proc vkEnumerateInstanceLayerProperties*(
pPropertyCount: ptr uint32;
pProperties: ptr VkLayerProperties;
): VkResult {.cdecl, importc.}
proc vkEnumerateDeviceLayerProperties*(
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkLayerProperties;
): VkResult {.cdecl, importc.}
proc vkGetDeviceQueue*(
device: VkDevice;
queueFamilyIndex: uint32;
queueIndex: uint32;
pQueue: ptr VkQueue;
): void {.cdecl, importc.}
proc vkQueueSubmit*(
queue: VkQueue;
submitCount: uint32;
pSubmits: ptr VkSubmitInfo;
fence: VkFence;
): VkResult {.cdecl, importc.}
proc vkQueueWaitIdle*(
queue: VkQueue;
): VkResult {.cdecl, importc.}
proc vkDeviceWaitIdle*(
device: VkDevice;
): VkResult {.cdecl, importc.}
proc vkAllocateMemory*(
device: VkDevice;
pAllocateInfo: ptr VkMemoryAllocateInfo;
pAllocator: ptr VkAllocationCallbacks;
pMemory: ptr VkDeviceMemory;
): VkResult {.cdecl, importc.}
proc vkFreeMemory*(
device: VkDevice;
memory: VkDeviceMemory;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkMapMemory*(
device: VkDevice;
memory: VkDeviceMemory;
offset: VkDeviceSize;
size: VkDeviceSize;
flags: VkMemoryMapFlags;
ppData: pointer;
): VkResult {.cdecl, importc.}
proc vkUnmapMemory*(
device: VkDevice;
memory: VkDeviceMemory;
): void {.cdecl, importc.}
proc vkFlushMappedMemoryRanges*(
device: VkDevice;
memoryRangeCount: uint32;
pMemoryRanges: ptr VkMappedMemoryRange;
): VkResult {.cdecl, importc.}
proc vkInvalidateMappedMemoryRanges*(
device: VkDevice;
memoryRangeCount: uint32;
pMemoryRanges: ptr VkMappedMemoryRange;
): VkResult {.cdecl, importc.}
proc vkGetDeviceMemoryCommitment*(
device: VkDevice;
memory: VkDeviceMemory;
pCommittedMemoryInBytes: ptr VkDeviceSize;
): void {.cdecl, importc.}
proc vkBindBufferMemory*(
device: VkDevice;
buffer: VkBuffer;
memory: VkDeviceMemory;
memoryOffset: VkDeviceSize;
): VkResult {.cdecl, importc.}
proc vkBindImageMemory*(
device: VkDevice;
image: VkImage;
memory: VkDeviceMemory;
memoryOffset: VkDeviceSize;
): VkResult {.cdecl, importc.}
proc vkGetBufferMemoryRequirements*(
device: VkDevice;
buffer: VkBuffer;
pMemoryRequirements: ptr VkMemoryRequirements;
): void {.cdecl, importc.}
proc vkGetImageMemoryRequirements*(
device: VkDevice;
image: VkImage;
pMemoryRequirements: ptr VkMemoryRequirements;
): void {.cdecl, importc.}
proc vkGetImageSparseMemoryRequirements*(
device: VkDevice;
image: VkImage;
pSparseMemoryRequirementCount: ptr uint32;
pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceSparseImageFormatProperties*(
physicalDevice: VkPhysicalDevice;
format: VkFormat;
theType: VkImageType;
samples: VkSampleCountFlagBits;
usage: VkImageUsageFlags;
tiling: VkImageTiling;
pPropertyCount: ptr uint32;
pProperties: ptr VkSparseImageFormatProperties;
): void {.cdecl, importc.}
proc vkQueueBindSparse*(
queue: VkQueue;
bindInfoCount: uint32;
pBindInfo: ptr VkBindSparseInfo;
fence: VkFence;
): VkResult {.cdecl, importc.}
proc vkCreateFence*(
device: VkDevice;
pCreateInfo: ptr VkFenceCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pFence: ptr VkFence;
): VkResult {.cdecl, importc.}
proc vkDestroyFence*(
device: VkDevice;
fence: VkFence;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkResetFences*(
device: VkDevice;
fenceCount: uint32;
pFences: ptr VkFence;
): VkResult {.cdecl, importc.}
proc vkGetFenceStatus*(
device: VkDevice;
fence: VkFence;
): VkResult {.cdecl, importc.}
proc vkWaitForFences*(
device: VkDevice;
fenceCount: uint32;
pFences: ptr VkFence;
waitAll: VkBool32;
timeout: uint64;
): VkResult {.cdecl, importc.}
proc vkCreateSemaphore*(
device: VkDevice;
pCreateInfo: ptr VkSemaphoreCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pSemaphore: ptr VkSemaphore;
): VkResult {.cdecl, importc.}
proc vkDestroySemaphore*(
device: VkDevice;
semaphore: VkSemaphore;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateEvent*(
device: VkDevice;
pCreateInfo: ptr VkEventCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pEvent: ptr VkEvent;
): VkResult {.cdecl, importc.}
proc vkDestroyEvent*(
device: VkDevice;
event: VkEvent;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetEventStatus*(
device: VkDevice;
event: VkEvent;
): VkResult {.cdecl, importc.}
proc vkSetEvent*(
device: VkDevice;
event: VkEvent;
): VkResult {.cdecl, importc.}
proc vkResetEvent*(
device: VkDevice;
event: VkEvent;
): VkResult {.cdecl, importc.}
proc vkCreateQueryPool*(
device: VkDevice;
pCreateInfo: ptr VkQueryPoolCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pQueryPool: ptr VkQueryPool;
): VkResult {.cdecl, importc.}
proc vkDestroyQueryPool*(
device: VkDevice;
queryPool: VkQueryPool;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetQueryPoolResults*(
device: VkDevice;
queryPool: VkQueryPool;
firstQuery: uint32;
queryCount: uint32;
dataSize: csize;
pData: pointer;
stride: VkDeviceSize;
flags: VkQueryResultFlags;
): VkResult {.cdecl, importc.}
proc vkCreateBuffer*(
device: VkDevice;
pCreateInfo: ptr VkBufferCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pBuffer: ptr VkBuffer;
): VkResult {.cdecl, importc.}
proc vkDestroyBuffer*(
device: VkDevice;
buffer: VkBuffer;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateBufferView*(
device: VkDevice;
pCreateInfo: ptr VkBufferViewCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pView: ptr VkBufferView;
): VkResult {.cdecl, importc.}
proc vkDestroyBufferView*(
device: VkDevice;
bufferView: VkBufferView;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateImage*(
device: VkDevice;
pCreateInfo: ptr VkImageCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pImage: ptr VkImage;
): VkResult {.cdecl, importc.}
proc vkDestroyImage*(
device: VkDevice;
image: VkImage;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetImageSubresourceLayout*(
device: VkDevice;
image: VkImage;
pSubresource: ptr VkImageSubresource;
pLayout: ptr VkSubresourceLayout;
): void {.cdecl, importc.}
proc vkCreateImageView*(
device: VkDevice;
pCreateInfo: ptr VkImageViewCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pView: ptr VkImageView;
): VkResult {.cdecl, importc.}
proc vkDestroyImageView*(
device: VkDevice;
imageView: VkImageView;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateShaderModule*(
device: VkDevice;
pCreateInfo: ptr VkShaderModuleCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pShaderModule: ptr VkShaderModule;
): VkResult {.cdecl, importc.}
proc vkDestroyShaderModule*(
device: VkDevice;
shaderModule: VkShaderModule;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreatePipelineCache*(
device: VkDevice;
pCreateInfo: ptr VkPipelineCacheCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelineCache: ptr VkPipelineCache;
): VkResult {.cdecl, importc.}
proc vkDestroyPipelineCache*(
device: VkDevice;
pipelineCache: VkPipelineCache;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetPipelineCacheData*(
device: VkDevice;
pipelineCache: VkPipelineCache;
pDataSize: ptr csize;
pData: pointer;
): VkResult {.cdecl, importc.}
proc vkMergePipelineCaches*(
device: VkDevice;
dstCache: VkPipelineCache;
srcCacheCount: uint32;
pSrcCaches: ptr VkPipelineCache;
): VkResult {.cdecl, importc.}
proc vkCreateGraphicsPipelines*(
device: VkDevice;
pipelineCache: VkPipelineCache;
createInfoCount: uint32;
pCreateInfos: ptr VkGraphicsPipelineCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelines: ptr VkPipeline;
): VkResult {.cdecl, importc.}
proc vkCreateComputePipelines*(
device: VkDevice;
pipelineCache: VkPipelineCache;
createInfoCount: uint32;
pCreateInfos: ptr VkComputePipelineCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelines: ptr VkPipeline;
): VkResult {.cdecl, importc.}
proc vkDestroyPipeline*(
device: VkDevice;
pipeline: VkPipeline;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreatePipelineLayout*(
device: VkDevice;
pCreateInfo: ptr VkPipelineLayoutCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pPipelineLayout: ptr VkPipelineLayout;
): VkResult {.cdecl, importc.}
proc vkDestroyPipelineLayout*(
device: VkDevice;
pipelineLayout: VkPipelineLayout;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateSampler*(
device: VkDevice;
pCreateInfo: ptr VkSamplerCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pSampler: ptr VkSampler;
): VkResult {.cdecl, importc.}
proc vkDestroySampler*(
device: VkDevice;
sampler: VkSampler;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateDescriptorSetLayout*(
device: VkDevice;
pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pSetLayout: ptr VkDescriptorSetLayout;
): VkResult {.cdecl, importc.}
proc vkDestroyDescriptorSetLayout*(
device: VkDevice;
descriptorSetLayout: VkDescriptorSetLayout;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateDescriptorPool*(
device: VkDevice;
pCreateInfo: ptr VkDescriptorPoolCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pDescriptorPool: ptr VkDescriptorPool;
): VkResult {.cdecl, importc.}
proc vkDestroyDescriptorPool*(
device: VkDevice;
descriptorPool: VkDescriptorPool;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkResetDescriptorPool*(
device: VkDevice;
descriptorPool: VkDescriptorPool;
flags: VkDescriptorPoolResetFlags;
): VkResult {.cdecl, importc.}
proc vkAllocateDescriptorSets*(
device: VkDevice;
pAllocateInfo: ptr VkDescriptorSetAllocateInfo;
pDescriptorSets: ptr VkDescriptorSet;
): VkResult {.cdecl, importc.}
proc vkFreeDescriptorSets*(
device: VkDevice;
descriptorPool: VkDescriptorPool;
descriptorSetCount: uint32;
pDescriptorSets: ptr VkDescriptorSet;
): VkResult {.cdecl, importc.}
proc vkUpdateDescriptorSets*(
device: VkDevice;
descriptorWriteCount: uint32;
pDescriptorWrites: ptr VkWriteDescriptorSet;
descriptorCopyCount: uint32;
pDescriptorCopies: ptr VkCopyDescriptorSet;
): void {.cdecl, importc.}
proc vkCreateFramebuffer*(
device: VkDevice;
pCreateInfo: ptr VkFramebufferCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pFramebuffer: ptr VkFramebuffer;
): VkResult {.cdecl, importc.}
proc vkDestroyFramebuffer*(
device: VkDevice;
framebuffer: VkFramebuffer;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateRenderPass*(
device: VkDevice;
pCreateInfo: ptr VkRenderPassCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pRenderPass: ptr VkRenderPass;
): VkResult {.cdecl, importc.}
proc vkDestroyRenderPass*(
device: VkDevice;
renderPass: VkRenderPass;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetRenderAreaGranularity*(
device: VkDevice;
renderPass: VkRenderPass;
pGranularity: ptr VkExtent2D;
): void {.cdecl, importc.}
proc vkCreateCommandPool*(
device: VkDevice;
pCreateInfo: ptr VkCommandPoolCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pCommandPool: ptr VkCommandPool;
): VkResult {.cdecl, importc.}
proc vkDestroyCommandPool*(
device: VkDevice;
commandPool: VkCommandPool;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkResetCommandPool*(
device: VkDevice;
commandPool: VkCommandPool;
flags: VkCommandPoolResetFlags;
): VkResult {.cdecl, importc.}
proc vkAllocateCommandBuffers*(
device: VkDevice;
pAllocateInfo: ptr VkCommandBufferAllocateInfo;
pCommandBuffers: ptr VkCommandBuffer;
): VkResult {.cdecl, importc.}
proc vkFreeCommandBuffers*(
device: VkDevice;
commandPool: VkCommandPool;
commandBufferCount: uint32;
pCommandBuffers: ptr VkCommandBuffer;
): void {.cdecl, importc.}
proc vkBeginCommandBuffer*(
commandBuffer: VkCommandBuffer;
pBeginInfo: ptr VkCommandBufferBeginInfo;
): VkResult {.cdecl, importc.}
proc vkEndCommandBuffer*(
commandBuffer: VkCommandBuffer;
): VkResult {.cdecl, importc.}
proc vkResetCommandBuffer*(
commandBuffer: VkCommandBuffer;
flags: VkCommandBufferResetFlags;
): VkResult {.cdecl, importc.}
proc vkCmdBindPipeline*(
commandBuffer: VkCommandBuffer;
pipelineBindPoint: VkPipelineBindPoint;
pipeline: VkPipeline;
): void {.cdecl, importc.}
proc vkCmdSetViewport*(
commandBuffer: VkCommandBuffer;
firstViewport: uint32;
viewportCount: uint32;
pViewports: ptr VkViewport;
): void {.cdecl, importc.}
proc vkCmdSetScissor*(
commandBuffer: VkCommandBuffer;
firstScissor: uint32;
scissorCount: uint32;
pScissors: ptr VkRect2D;
): void {.cdecl, importc.}
proc vkCmdSetLineWidth*(
commandBuffer: VkCommandBuffer;
lineWidth: cfloat;
): void {.cdecl, importc.}
proc vkCmdSetDepthBias*(
commandBuffer: VkCommandBuffer;
depthBiasConstantFactor: cfloat;
depthBiasClamp: cfloat;
depthBiasSlopeFactor: cfloat;
): void {.cdecl, importc.}
proc vkCmdSetBlendConstants*(
commandBuffer: VkCommandBuffer;
blendConstants: array[4, cfloat];
): void {.cdecl, importc.}
proc vkCmdSetDepthBounds*(
commandBuffer: VkCommandBuffer;
minDepthBounds: cfloat;
maxDepthBounds: cfloat;
): void {.cdecl, importc.}
proc vkCmdSetStencilCompareMask*(
commandBuffer: VkCommandBuffer;
faceMask: VkStencilFaceFlags;
compareMask: uint32;
): void {.cdecl, importc.}
proc vkCmdSetStencilWriteMask*(
commandBuffer: VkCommandBuffer;
faceMask: VkStencilFaceFlags;
writeMask: uint32;
): void {.cdecl, importc.}
proc vkCmdSetStencilReference*(
commandBuffer: VkCommandBuffer;
faceMask: VkStencilFaceFlags;
reference: uint32;
): void {.cdecl, importc.}
proc vkCmdBindDescriptorSets*(
commandBuffer: VkCommandBuffer;
pipelineBindPoint: VkPipelineBindPoint;
layout: VkPipelineLayout;
firstSet: uint32;
descriptorSetCount: uint32;
pDescriptorSets: ptr VkDescriptorSet;
dynamicOffsetCount: uint32;
pDynamicOffsets: ptr uint32;
): void {.cdecl, importc.}
proc vkCmdBindIndexBuffer*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
indexType: VkIndexType;
): void {.cdecl, importc.}
proc vkCmdBindVertexBuffers*(
commandBuffer: VkCommandBuffer;
firstBinding: uint32;
bindingCount: uint32;
pBuffers: ptr VkBuffer;
pOffsets: ptr VkDeviceSize;
): void {.cdecl, importc.}
proc vkCmdDraw*(
commandBuffer: VkCommandBuffer;
vertexCount: uint32;
instanceCount: uint32;
firstVertex: uint32;
firstInstance: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawIndexed*(
commandBuffer: VkCommandBuffer;
indexCount: uint32;
instanceCount: uint32;
firstIndex: uint32;
vertexOffset: int32;
firstInstance: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawIndirect*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
drawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawIndexedIndirect*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
drawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdDispatch*(
commandBuffer: VkCommandBuffer;
groupCountX: uint32;
groupCountY: uint32;
groupCountZ: uint32;
): void {.cdecl, importc.}
proc vkCmdDispatchIndirect*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
): void {.cdecl, importc.}
proc vkCmdCopyBuffer*(
commandBuffer: VkCommandBuffer;
srcBuffer: VkBuffer;
dstBuffer: VkBuffer;
regionCount: uint32;
pRegions: ptr VkBufferCopy;
): void {.cdecl, importc.}
proc vkCmdCopyImage*(
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkImageCopy;
): void {.cdecl, importc.}
proc vkCmdBlitImage*(
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkImageBlit;
filter: VkFilter;
): void {.cdecl, importc.}
proc vkCmdCopyBufferToImage*(
commandBuffer: VkCommandBuffer;
srcBuffer: VkBuffer;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkBufferImageCopy;
): void {.cdecl, importc.}
proc vkCmdCopyImageToBuffer*(
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstBuffer: VkBuffer;
regionCount: uint32;
pRegions: ptr VkBufferImageCopy;
): void {.cdecl, importc.}
proc vkCmdUpdateBuffer*(
commandBuffer: VkCommandBuffer;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
dataSize: VkDeviceSize;
pData: pointer;
): void {.cdecl, importc.}
proc vkCmdFillBuffer*(
commandBuffer: VkCommandBuffer;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
size: VkDeviceSize;
data: uint32;
): void {.cdecl, importc.}
proc vkCmdClearColorImage*(
commandBuffer: VkCommandBuffer;
image: VkImage;
imageLayout: VkImageLayout;
pColor: ptr VkClearColorValue;
rangeCount: uint32;
pRanges: ptr VkImageSubresourceRange;
): void {.cdecl, importc.}
proc vkCmdClearDepthStencilImage*(
commandBuffer: VkCommandBuffer;
image: VkImage;
imageLayout: VkImageLayout;
pDepthStencil: ptr VkClearDepthStencilValue;
rangeCount: uint32;
pRanges: ptr VkImageSubresourceRange;
): void {.cdecl, importc.}
proc vkCmdClearAttachments*(
commandBuffer: VkCommandBuffer;
attachmentCount: uint32;
pAttachments: ptr VkClearAttachment;
rectCount: uint32;
pRects: ptr VkClearRect;
): void {.cdecl, importc.}
proc vkCmdResolveImage*(
commandBuffer: VkCommandBuffer;
srcImage: VkImage;
srcImageLayout: VkImageLayout;
dstImage: VkImage;
dstImageLayout: VkImageLayout;
regionCount: uint32;
pRegions: ptr VkImageResolve;
): void {.cdecl, importc.}
proc vkCmdSetEvent*(
commandBuffer: VkCommandBuffer;
event: VkEvent;
stageMask: VkPipelineStageFlags;
): void {.cdecl, importc.}
proc vkCmdResetEvent*(
commandBuffer: VkCommandBuffer;
event: VkEvent;
stageMask: VkPipelineStageFlags;
): void {.cdecl, importc.}
proc vkCmdWaitEvents*(
commandBuffer: VkCommandBuffer;
eventCount: uint32;
pEvents: ptr VkEvent;
srcStageMask: VkPipelineStageFlags;
dstStageMask: VkPipelineStageFlags;
memoryBarrierCount: uint32;
pMemoryBarriers: ptr VkMemoryBarrier;
bufferMemoryBarrierCount: uint32;
pBufferMemoryBarriers: ptr VkBufferMemoryBarrier;
imageMemoryBarrierCount: uint32;
pImageMemoryBarriers: ptr VkImageMemoryBarrier;
): void {.cdecl, importc.}
proc vkCmdPipelineBarrier*(
commandBuffer: VkCommandBuffer;
srcStageMask: VkPipelineStageFlags;
dstStageMask: VkPipelineStageFlags;
dependencyFlags: VkDependencyFlags;
memoryBarrierCount: uint32;
pMemoryBarriers: ptr VkMemoryBarrier;
bufferMemoryBarrierCount: uint32;
pBufferMemoryBarriers: ptr VkBufferMemoryBarrier;
imageMemoryBarrierCount: uint32;
pImageMemoryBarriers: ptr VkImageMemoryBarrier;
): void {.cdecl, importc.}
proc vkCmdBeginQuery*(
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
query: uint32;
flags: VkQueryControlFlags;
): void {.cdecl, importc.}
proc vkCmdEndQuery*(
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
query: uint32;
): void {.cdecl, importc.}
proc vkCmdResetQueryPool*(
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
firstQuery: uint32;
queryCount: uint32;
): void {.cdecl, importc.}
proc vkCmdWriteTimestamp*(
commandBuffer: VkCommandBuffer;
pipelineStage: VkPipelineStageFlagBits;
queryPool: VkQueryPool;
query: uint32;
): void {.cdecl, importc.}
proc vkCmdCopyQueryPoolResults*(
commandBuffer: VkCommandBuffer;
queryPool: VkQueryPool;
firstQuery: uint32;
queryCount: uint32;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
stride: VkDeviceSize;
flags: VkQueryResultFlags;
): void {.cdecl, importc.}
proc vkCmdPushConstants*(
commandBuffer: VkCommandBuffer;
layout: VkPipelineLayout;
stageFlags: VkShaderStageFlags;
offset: uint32;
size: uint32;
pValues: pointer;
): void {.cdecl, importc.}
proc vkCmdBeginRenderPass*(
commandBuffer: VkCommandBuffer;
pRenderPassBegin: ptr VkRenderPassBeginInfo;
contents: VkSubpassContents;
): void {.cdecl, importc.}
proc vkCmdNextSubpass*(
commandBuffer: VkCommandBuffer;
contents: VkSubpassContents;
): void {.cdecl, importc.}
proc vkCmdEndRenderPass*(
commandBuffer: VkCommandBuffer;
): void {.cdecl, importc.}
proc vkCmdExecuteCommands*(
commandBuffer: VkCommandBuffer;
commandBufferCount: uint32;
pCommandBuffers: ptr VkCommandBuffer;
): void {.cdecl, importc.}
proc vkEnumerateInstanceVersion*(
pApiVersion: ptr uint32;
): VkResult {.cdecl, importc.}
proc vkBindBufferMemory2*(
device: VkDevice;
bindInfoCount: uint32;
pBindInfos: ptr VkBindBufferMemoryInfo;
): VkResult {.cdecl, importc.}
proc vkBindImageMemory2*(
device: VkDevice;
bindInfoCount: uint32;
pBindInfos: ptr VkBindImageMemoryInfo;
): VkResult {.cdecl, importc.}
proc vkGetDeviceGroupPeerMemoryFeatures*(
device: VkDevice;
heapIndex: uint32;
localDeviceIndex: uint32;
remoteDeviceIndex: uint32;
pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags;
): void {.cdecl, importc.}
proc vkCmdSetDeviceMask*(
commandBuffer: VkCommandBuffer;
deviceMask: uint32;
): void {.cdecl, importc.}
proc vkCmdDispatchBase*(
commandBuffer: VkCommandBuffer;
baseGroupX: uint32;
baseGroupY: uint32;
baseGroupZ: uint32;
groupCountX: uint32;
groupCountY: uint32;
groupCountZ: uint32;
): void {.cdecl, importc.}
proc vkEnumeratePhysicalDeviceGroups*(
instance: VkInstance;
pPhysicalDeviceGroupCount: ptr uint32;
pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties;
): VkResult {.cdecl, importc.}
proc vkGetImageMemoryRequirements2*(
device: VkDevice;
pInfo: ptr VkImageMemoryRequirementsInfo2;
pMemoryRequirements: ptr VkMemoryRequirements2;
): void {.cdecl, importc.}
proc vkGetBufferMemoryRequirements2*(
device: VkDevice;
pInfo: ptr VkBufferMemoryRequirementsInfo2;
pMemoryRequirements: ptr VkMemoryRequirements2;
): void {.cdecl, importc.}
proc vkGetImageSparseMemoryRequirements2*(
device: VkDevice;
pInfo: ptr VkImageSparseMemoryRequirementsInfo2;
pSparseMemoryRequirementCount: ptr uint32;
pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceFeatures2*(
physicalDevice: VkPhysicalDevice;
pFeatures: ptr VkPhysicalDeviceFeatures2;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceProperties2*(
physicalDevice: VkPhysicalDevice;
pProperties: ptr VkPhysicalDeviceProperties2;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceFormatProperties2*(
physicalDevice: VkPhysicalDevice;
format: VkFormat;
pFormatProperties: ptr VkFormatProperties2;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceImageFormatProperties2*(
physicalDevice: VkPhysicalDevice;
pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2;
pImageFormatProperties: ptr VkImageFormatProperties2;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceQueueFamilyProperties2*(
physicalDevice: VkPhysicalDevice;
pQueueFamilyPropertyCount: ptr uint32;
pQueueFamilyProperties: ptr VkQueueFamilyProperties2;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceMemoryProperties2*(
physicalDevice: VkPhysicalDevice;
pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceSparseImageFormatProperties2*(
physicalDevice: VkPhysicalDevice;
pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2;
pPropertyCount: ptr uint32;
pProperties: ptr VkSparseImageFormatProperties2;
): void {.cdecl, importc.}
proc vkTrimCommandPool*(
device: VkDevice;
commandPool: VkCommandPool;
flags: VkCommandPoolTrimFlags;
): void {.cdecl, importc.}
proc vkGetDeviceQueue2*(
device: VkDevice;
pQueueInfo: ptr VkDeviceQueueInfo2;
pQueue: ptr VkQueue;
): void {.cdecl, importc.}
proc vkCreateSamplerYcbcrConversion*(
device: VkDevice;
pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pYcbcrConversion: ptr VkSamplerYcbcrConversion;
): VkResult {.cdecl, importc.}
proc vkDestroySamplerYcbcrConversion*(
device: VkDevice;
ycbcrConversion: VkSamplerYcbcrConversion;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateDescriptorUpdateTemplate*(
device: VkDevice;
pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo;
pAllocator: ptr VkAllocationCallbacks;
pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate;
): VkResult {.cdecl, importc.}
proc vkDestroyDescriptorUpdateTemplate*(
device: VkDevice;
descriptorUpdateTemplate: VkDescriptorUpdateTemplate;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkUpdateDescriptorSetWithTemplate*(
device: VkDevice;
descriptorSet: VkDescriptorSet;
descriptorUpdateTemplate: VkDescriptorUpdateTemplate;
pData: pointer;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceExternalBufferProperties*(
physicalDevice: VkPhysicalDevice;
pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo;
pExternalBufferProperties: ptr VkExternalBufferProperties;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceExternalFenceProperties*(
physicalDevice: VkPhysicalDevice;
pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo;
pExternalFenceProperties: ptr VkExternalFenceProperties;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceExternalSemaphoreProperties*(
physicalDevice: VkPhysicalDevice;
pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo;
pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties;
): void {.cdecl, importc.}
proc vkGetDescriptorSetLayoutSupport*(
device: VkDevice;
pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo;
pSupport: ptr VkDescriptorSetLayoutSupport;
): void {.cdecl, importc.}
proc vkImportSemaphoreFdKHR*(
device: VkDevice;
pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR;
): VkResult {.cdecl, importc.}
proc vkGetSemaphoreFdKHR*(
device: VkDevice;
pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR;
pFd: ptr int;
): VkResult {.cdecl, importc.}
proc vkCreateSwapchainKHR*(
device: VkDevice;
pCreateInfo: ptr VkSwapchainCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pSwapchain: ptr VkSwapchainKHR;
): VkResult {.cdecl, importc.}
proc vkDestroySwapchainKHR*(
device: VkDevice;
swapchain: VkSwapchainKHR;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetSwapchainImagesKHR*(
device: VkDevice;
swapchain: VkSwapchainKHR;
pSwapchainImageCount: ptr uint32;
pSwapchainImages: ptr VkImage;
): VkResult {.cdecl, importc.}
proc vkAcquireNextImageKHR*(
device: VkDevice;
swapchain: VkSwapchainKHR;
timeout: uint64;
semaphore: VkSemaphore;
fence: VkFence;
pImageIndex: ptr uint32;
): VkResult {.cdecl, importc.}
proc vkQueuePresentKHR*(
queue: VkQueue;
pPresentInfo: ptr VkPresentInfoKHR;
): VkResult {.cdecl, importc.}
proc vkGetDeviceGroupPresentCapabilitiesKHR*(
device: VkDevice;
pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR;
): VkResult {.cdecl, importc.}
proc vkGetDeviceGroupSurfacePresentModesKHR*(
device: VkDevice;
surface: VkSurfaceKHR;
pModes: ptr VkDeviceGroupPresentModeFlagsKHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDevicePresentRectanglesKHR*(
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pRectCount: ptr uint32;
pRects: ptr VkRect2D;
): VkResult {.cdecl, importc.}
proc vkAcquireNextImage2KHR*(
device: VkDevice;
pAcquireInfo: ptr VkAcquireNextImageInfoKHR;
pImageIndex: ptr uint32;
): VkResult {.cdecl, importc.}
proc vkCmdDrawIndirectCountAMD*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawIndexedIndirectCountAMD*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdWriteBufferMarkerAMD*(
commandBuffer: VkCommandBuffer;
pipelineStage: VkPipelineStageFlagBits;
dstBuffer: VkBuffer;
dstOffset: VkDeviceSize;
marker: uint32;
): void {.cdecl, importc.}
proc vkCmdPushDescriptorSetKHR*(
commandBuffer: VkCommandBuffer;
pipelineBindPoint: VkPipelineBindPoint;
layout: VkPipelineLayout;
set: uint32;
descriptorWriteCount: uint32;
pDescriptorWrites: ptr VkWriteDescriptorSet;
): void {.cdecl, importc.}
proc vkCmdPushDescriptorSetWithTemplateKHR*(
commandBuffer: VkCommandBuffer;
descriptorUpdateTemplate: VkDescriptorUpdateTemplate;
layout: VkPipelineLayout;
set: uint32;
pData: pointer;
): void {.cdecl, importc.}
proc vkCreateDebugReportCallbackEXT*(
instance: VkInstance;
pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pCallback: ptr VkDebugReportCallbackEXT;
): VkResult {.cdecl, importc.}
proc vkDestroyDebugReportCallbackEXT*(
instance: VkInstance;
callback: VkDebugReportCallbackEXT;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkDebugReportMessageEXT*(
instance: VkInstance;
flags: VkDebugReportFlagsEXT;
objectType: VkDebugReportObjectTypeEXT;
theObject: uint64;
location: csize;
messageCode: int32;
pLayerPrefix: cstring;
pMessage: cstring;
): void {.cdecl, importc.}
proc vkReleaseDisplayEXT*(
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
): VkResult {.cdecl, importc.}
proc vkCreateValidationCacheEXT*(
device: VkDevice;
pCreateInfo: ptr VkValidationCacheCreateInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pValidationCache: ptr VkValidationCacheEXT;
): VkResult {.cdecl, importc.}
proc vkDestroyValidationCacheEXT*(
device: VkDevice;
validationCache: VkValidationCacheEXT;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkMergeValidationCachesEXT*(
device: VkDevice;
dstCache: VkValidationCacheEXT;
srcCacheCount: uint32;
pSrcCaches: ptr VkValidationCacheEXT;
): VkResult {.cdecl, importc.}
proc vkGetValidationCacheDataEXT*(
device: VkDevice;
validationCache: VkValidationCacheEXT;
pDataSize: ptr csize;
pData: pointer;
): VkResult {.cdecl, importc.}
proc vkDisplayPowerControlEXT*(
device: VkDevice;
display: VkDisplayKHR;
pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT;
): VkResult {.cdecl, importc.}
proc vkRegisterDeviceEventEXT*(
device: VkDevice;
pDeviceEventInfo: ptr VkDeviceEventInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pFence: ptr VkFence;
): VkResult {.cdecl, importc.}
proc vkRegisterDisplayEventEXT*(
device: VkDevice;
display: VkDisplayKHR;
pDisplayEventInfo: ptr VkDisplayEventInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pFence: ptr VkFence;
): VkResult {.cdecl, importc.}
proc vkGetSwapchainCounterEXT*(
device: VkDevice;
swapchain: VkSwapchainKHR;
counter: VkSurfaceCounterFlagBitsEXT;
pCounterValue: ptr uint64;
): VkResult {.cdecl, importc.}
proc vkCmdBeginConditionalRenderingEXT*(
commandBuffer: VkCommandBuffer;
pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT;
): void {.cdecl, importc.}
proc vkCmdEndConditionalRenderingEXT*(
commandBuffer: VkCommandBuffer;
): void {.cdecl, importc.}
proc vkCmdSetExclusiveScissorNV*(
commandBuffer: VkCommandBuffer;
firstExclusiveScissor: uint32;
exclusiveScissorCount: uint32;
pExclusiveScissors: ptr VkRect2D;
): void {.cdecl, importc.}
proc vkDebugMarkerSetObjectTagEXT*(
device: VkDevice;
pTagInfo: ptr VkDebugMarkerObjectTagInfoEXT;
): VkResult {.cdecl, importc.}
proc vkDebugMarkerSetObjectNameEXT*(
device: VkDevice;
pNameInfo: ptr VkDebugMarkerObjectNameInfoEXT;
): VkResult {.cdecl, importc.}
proc vkCmdDebugMarkerBeginEXT*(
commandBuffer: VkCommandBuffer;
pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT;
): void {.cdecl, importc.}
proc vkCmdDebugMarkerEndEXT*(
commandBuffer: VkCommandBuffer;
): void {.cdecl, importc.}
proc vkCmdDebugMarkerInsertEXT*(
commandBuffer: VkCommandBuffer;
pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT;
): void {.cdecl, importc.}
proc vkImportFenceFdKHR*(
device: VkDevice;
pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR;
): VkResult {.cdecl, importc.}
proc vkGetFenceFdKHR*(
device: VkDevice;
pGetFdInfo: ptr VkFenceGetFdInfoKHR;
pFd: ptr int;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfaceCapabilities2EXT*(
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT;
): VkResult {.cdecl, importc.}
proc vkCreateRenderPass2KHR*(
device: VkDevice;
pCreateInfo: ptr VkRenderPassCreateInfo2KHR;
pAllocator: ptr VkAllocationCallbacks;
pRenderPass: ptr VkRenderPass;
): VkResult {.cdecl, importc.}
proc vkCmdBeginRenderPass2KHR*(
commandBuffer: VkCommandBuffer;
pRenderPassBegin: ptr VkRenderPassBeginInfo;
pSubpassBeginInfo: ptr VkSubpassBeginInfoKHR;
): void {.cdecl, importc.}
proc vkCmdNextSubpass2KHR*(
commandBuffer: VkCommandBuffer;
pSubpassBeginInfo: ptr VkSubpassBeginInfoKHR;
pSubpassEndInfo: ptr VkSubpassEndInfoKHR;
): void {.cdecl, importc.}
proc vkCmdEndRenderPass2KHR*(
commandBuffer: VkCommandBuffer;
pSubpassEndInfo: ptr VkSubpassEndInfoKHR;
): void {.cdecl, importc.}
proc vkGetMemoryHostPointerPropertiesEXT*(
device: VkDevice;
handleType: VkExternalMemoryHandleTypeFlagBits;
pHostPointer: pointer;
pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceDisplayPropertiesKHR*(
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayPropertiesKHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceDisplayPlanePropertiesKHR*(
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayPlanePropertiesKHR;
): VkResult {.cdecl, importc.}
proc vkGetDisplayPlaneSupportedDisplaysKHR*(
physicalDevice: VkPhysicalDevice;
planeIndex: uint32;
pDisplayCount: ptr uint32;
pDisplays: ptr VkDisplayKHR;
): VkResult {.cdecl, importc.}
proc vkGetDisplayModePropertiesKHR*(
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayModePropertiesKHR;
): VkResult {.cdecl, importc.}
proc vkCreateDisplayModeKHR*(
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
pCreateInfo: ptr VkDisplayModeCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pMode: ptr VkDisplayModeKHR;
): VkResult {.cdecl, importc.}
proc vkGetDisplayPlaneCapabilitiesKHR*(
physicalDevice: VkPhysicalDevice;
mode: VkDisplayModeKHR;
planeIndex: uint32;
pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR;
): VkResult {.cdecl, importc.}
proc vkCreateDisplayPlaneSurfaceKHR*(
instance: VkInstance;
pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pSurface: ptr VkSurfaceKHR;
): VkResult {.cdecl, importc.}
proc vkGetRefreshCycleDurationGOOGLE*(
device: VkDevice;
swapchain: VkSwapchainKHR;
pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE;
): VkResult {.cdecl, importc.}
proc vkGetPastPresentationTimingGOOGLE*(
device: VkDevice;
swapchain: VkSwapchainKHR;
pPresentationTimingCount: ptr uint32;
pPresentationTimings: ptr VkPastPresentationTimingGOOGLE;
): VkResult {.cdecl, importc.}
proc vkCmdSetSampleLocationsEXT*(
commandBuffer: VkCommandBuffer;
pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceMultisamplePropertiesEXT*(
physicalDevice: VkPhysicalDevice;
samples: VkSampleCountFlagBits;
pMultisampleProperties: ptr VkMultisamplePropertiesEXT;
): void {.cdecl, importc.}
proc vkCmdSetDiscardRectangleEXT*(
commandBuffer: VkCommandBuffer;
firstDiscardRectangle: uint32;
discardRectangleCount: uint32;
pDiscardRectangles: ptr VkRect2D;
): void {.cdecl, importc.}
proc vkCmdDrawIndirectCountKHR*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawIndexedIndirectCountKHR*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkGetShaderInfoAMD*(
device: VkDevice;
pipeline: VkPipeline;
shaderStage: VkShaderStageFlagBits;
infoType: VkShaderInfoTypeAMD;
pInfoSize: ptr csize;
pInfo: pointer;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceDisplayProperties2KHR*(
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayProperties2KHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceDisplayPlaneProperties2KHR*(
physicalDevice: VkPhysicalDevice;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayPlaneProperties2KHR;
): VkResult {.cdecl, importc.}
proc vkGetDisplayModeProperties2KHR*(
physicalDevice: VkPhysicalDevice;
display: VkDisplayKHR;
pPropertyCount: ptr uint32;
pProperties: ptr VkDisplayModeProperties2KHR;
): VkResult {.cdecl, importc.}
proc vkGetDisplayPlaneCapabilities2KHR*(
physicalDevice: VkPhysicalDevice;
pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR;
pCapabilities: ptr VkDisplayPlaneCapabilities2KHR;
): VkResult {.cdecl, importc.}
proc vkCmdProcessCommandsNVX*(
commandBuffer: VkCommandBuffer;
pProcessCommandsInfo: ptr VkCmdProcessCommandsInfoNVX;
): void {.cdecl, importc.}
proc vkCmdReserveSpaceForCommandsNVX*(
commandBuffer: VkCommandBuffer;
pReserveSpaceInfo: ptr VkCmdReserveSpaceForCommandsInfoNVX;
): void {.cdecl, importc.}
proc vkCreateIndirectCommandsLayoutNVX*(
device: VkDevice;
pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNVX;
): VkResult {.cdecl, importc.}
proc vkDestroyIndirectCommandsLayoutNVX*(
device: VkDevice;
indirectCommandsLayout: VkIndirectCommandsLayoutNVX;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkCreateObjectTableNVX*(
device: VkDevice;
pCreateInfo: ptr VkObjectTableCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pObjectTable: ptr VkObjectTableNVX;
): VkResult {.cdecl, importc.}
proc vkDestroyObjectTableNVX*(
device: VkDevice;
objectTable: VkObjectTableNVX;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkRegisterObjectsNVX*(
device: VkDevice;
objectTable: VkObjectTableNVX;
objectCount: uint32;
ppObjectTableEntries: ptr VkObjectTableEntryNVX;
pObjectIndices: ptr uint32;
): VkResult {.cdecl, importc.}
proc vkUnregisterObjectsNVX*(
device: VkDevice;
objectTable: VkObjectTableNVX;
objectCount: uint32;
pObjectEntryTypes: ptr VkObjectEntryTypeNVX;
pObjectIndices: ptr uint32;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX*(
physicalDevice: VkPhysicalDevice;
pFeatures: ptr VkDeviceGeneratedCommandsFeaturesNVX;
pLimits: ptr VkDeviceGeneratedCommandsLimitsNVX;
): void {.cdecl, importc.}
proc vkDestroySurfaceKHR*(
instance: VkInstance;
surface: VkSurfaceKHR;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfaceSupportKHR*(
physicalDevice: VkPhysicalDevice;
queueFamilyIndex: uint32;
surface: VkSurfaceKHR;
pSupported: ptr VkBool32;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfaceCapabilitiesKHR*(
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfaceFormatsKHR*(
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pSurfaceFormatCount: ptr uint32;
pSurfaceFormats: ptr VkSurfaceFormatKHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfacePresentModesKHR*(
physicalDevice: VkPhysicalDevice;
surface: VkSurfaceKHR;
pPresentModeCount: ptr uint32;
pPresentModes: ptr VkPresentModeKHR;
): VkResult {.cdecl, importc.}
proc vkCmdSetCheckpointNV*(
commandBuffer: VkCommandBuffer;
pCheckpointMarker: pointer;
): void {.cdecl, importc.}
proc vkGetQueueCheckpointDataNV*(
queue: VkQueue;
pCheckpointDataCount: ptr uint32;
pCheckpointData: ptr VkCheckpointDataNV;
): void {.cdecl, importc.}
proc vkCreateAccelerationStructureNVX*(
device: VkDevice;
pCreateInfo: ptr VkAccelerationStructureCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pAccelerationStructure: ptr VkAccelerationStructureNVX;
): VkResult {.cdecl, importc.}
proc vkDestroyAccelerationStructureNVX*(
device: VkDevice;
accelerationStructure: VkAccelerationStructureNVX;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkGetAccelerationStructureMemoryRequirementsNVX*(
device: VkDevice;
pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNVX;
pMemoryRequirements: ptr VkMemoryRequirements2KHR;
): void {.cdecl, importc.}
proc vkGetAccelerationStructureScratchMemoryRequirementsNVX*(
device: VkDevice;
pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNVX;
pMemoryRequirements: ptr VkMemoryRequirements2KHR;
): void {.cdecl, importc.}
proc vkBindAccelerationStructureMemoryNVX*(
device: VkDevice;
bindInfoCount: uint32;
pBindInfos: ptr VkBindAccelerationStructureMemoryInfoNVX;
): VkResult {.cdecl, importc.}
proc vkCmdBuildAccelerationStructureNVX*(
cmdBuf: VkCommandBuffer;
theType: VkAccelerationStructureTypeNVX;
instanceCount: uint32;
instanceData: VkBuffer;
instanceOffset: VkDeviceSize;
geometryCount: uint32;
pGeometries: ptr VkGeometryNVX;
flags: VkBuildAccelerationStructureFlagsNVX;
update: VkBool32;
dst: VkAccelerationStructureNVX;
src: VkAccelerationStructureNVX;
scratch: VkBuffer;
scratchOffset: VkDeviceSize;
): void {.cdecl, importc.}
proc vkCmdCopyAccelerationStructureNVX*(
cmdBuf: VkCommandBuffer;
dst: VkAccelerationStructureNVX;
src: VkAccelerationStructureNVX;
mode: VkCopyAccelerationStructureModeNVX;
): void {.cdecl, importc.}
proc vkCmdTraceRaysNVX*(
cmdBuf: VkCommandBuffer;
raygenShaderBindingTableBuffer: VkBuffer;
raygenShaderBindingOffset: VkDeviceSize;
missShaderBindingTableBuffer: VkBuffer;
missShaderBindingOffset: VkDeviceSize;
missShaderBindingStride: VkDeviceSize;
hitShaderBindingTableBuffer: VkBuffer;
hitShaderBindingOffset: VkDeviceSize;
hitShaderBindingStride: VkDeviceSize;
width: uint32;
height: uint32;
): void {.cdecl, importc.}
proc vkCreateRaytracingPipelinesNVX*(
device: VkDevice;
pipelineCache: VkPipelineCache;
createInfoCount: uint32;
pCreateInfos: ptr VkRaytracingPipelineCreateInfoNVX;
pAllocator: ptr VkAllocationCallbacks;
pPipelines: ptr VkPipeline;
): VkResult {.cdecl, importc.}
proc vkGetRaytracingShaderHandlesNVX*(
device: VkDevice;
pipeline: VkPipeline;
firstGroup: uint32;
groupCount: uint32;
dataSize: csize;
pData: pointer;
): VkResult {.cdecl, importc.}
proc vkGetAccelerationStructureHandleNVX*(
device: VkDevice;
accelerationStructure: VkAccelerationStructureNVX;
dataSize: csize;
pData: pointer;
): VkResult {.cdecl, importc.}
proc vkCmdWriteAccelerationStructurePropertiesNVX*(
cmdBuf: VkCommandBuffer;
accelerationStructure: VkAccelerationStructureNVX;
queryType: VkQueryType;
queryPool: VkQueryPool;
query: uint32;
): void {.cdecl, importc.}
proc vkCompileDeferredNVX*(
device: VkDevice;
pipeline: VkPipeline;
shader: uint32;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfaceCapabilities2KHR*(
physicalDevice: VkPhysicalDevice;
pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR;
pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceSurfaceFormats2KHR*(
physicalDevice: VkPhysicalDevice;
pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR;
pSurfaceFormatCount: ptr uint32;
pSurfaceFormats: ptr VkSurfaceFormat2KHR;
): VkResult {.cdecl, importc.}
proc vkGetPhysicalDeviceExternalImageFormatPropertiesNV*(
physicalDevice: VkPhysicalDevice;
format: VkFormat;
theType: VkImageType;
tiling: VkImageTiling;
usage: VkImageUsageFlags;
flags: VkImageCreateFlags;
externalHandleType: VkExternalMemoryHandleTypeFlagsNV;
pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV;
): VkResult {.cdecl, importc.}
proc vkGetSwapchainStatusKHR*(
device: VkDevice;
swapchain: VkSwapchainKHR;
): VkResult {.cdecl, importc.}
proc vkCreateSharedSwapchainsKHR*(
device: VkDevice;
swapchainCount: uint32;
pCreateInfos: ptr VkSwapchainCreateInfoKHR;
pAllocator: ptr VkAllocationCallbacks;
pSwapchains: ptr VkSwapchainKHR;
): VkResult {.cdecl, importc.}
proc vkSetHdrMetadataEXT*(
device: VkDevice;
swapchainCount: uint32;
pSwapchains: ptr VkSwapchainKHR;
pMetadata: ptr VkHdrMetadataEXT;
): void {.cdecl, importc.}
proc vkCmdSetViewportWScalingNV*(
commandBuffer: VkCommandBuffer;
firstViewport: uint32;
viewportCount: uint32;
pViewportWScalings: ptr VkViewportWScalingNV;
): void {.cdecl, importc.}
proc vkSetDebugUtilsObjectNameEXT*(
device: VkDevice;
pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT;
): VkResult {.cdecl, importc.}
proc vkSetDebugUtilsObjectTagEXT*(
device: VkDevice;
pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT;
): VkResult {.cdecl, importc.}
proc vkQueueBeginDebugUtilsLabelEXT*(
queue: VkQueue;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl, importc.}
proc vkQueueEndDebugUtilsLabelEXT*(
queue: VkQueue;
): void {.cdecl, importc.}
proc vkQueueInsertDebugUtilsLabelEXT*(
queue: VkQueue;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl, importc.}
proc vkCmdBeginDebugUtilsLabelEXT*(
commandBuffer: VkCommandBuffer;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl, importc.}
proc vkCmdEndDebugUtilsLabelEXT*(
commandBuffer: VkCommandBuffer;
): void {.cdecl, importc.}
proc vkCmdInsertDebugUtilsLabelEXT*(
commandBuffer: VkCommandBuffer;
pLabelInfo: ptr VkDebugUtilsLabelEXT;
): void {.cdecl, importc.}
proc vkCreateDebugUtilsMessengerEXT*(
instance: VkInstance;
pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT;
pAllocator: ptr VkAllocationCallbacks;
pMessenger: ptr VkDebugUtilsMessengerEXT;
): VkResult {.cdecl, importc.}
proc vkDestroyDebugUtilsMessengerEXT*(
instance: VkInstance;
messenger: VkDebugUtilsMessengerEXT;
pAllocator: ptr VkAllocationCallbacks;
): void {.cdecl, importc.}
proc vkSubmitDebugUtilsMessageEXT*(
instance: VkInstance;
messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT;
messageTypes: VkDebugUtilsMessageTypeFlagsEXT;
pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT;
): void {.cdecl, importc.}
proc vkCmdDrawMeshTasksNV*(
commandBuffer: VkCommandBuffer;
taskCount: uint32;
firstTask: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawMeshTasksIndirectNV*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
drawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdDrawMeshTasksIndirectCountNV*(
commandBuffer: VkCommandBuffer;
buffer: VkBuffer;
offset: VkDeviceSize;
countBuffer: VkBuffer;
countBufferOffset: VkDeviceSize;
maxDrawCount: uint32;
stride: uint32;
): void {.cdecl, importc.}
proc vkCmdBindShadingRateImageNV*(
commandBuffer: VkCommandBuffer;
imageView: VkImageView;
imageLayout: VkImageLayout;
): void {.cdecl, importc.}
proc vkCmdSetViewportShadingRatePaletteNV*(
commandBuffer: VkCommandBuffer;
firstViewport: uint32;
viewportCount: uint32;
pShadingRatePalettes: ptr VkShadingRatePaletteNV;
): void {.cdecl, importc.}
proc vkCmdSetCoarseSampleOrderNV*(
commandBuffer: VkCommandBuffer;
sampleOrderType: VkCoarseSampleOrderTypeNV;
customSampleOrderCount: uint32;
pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV;
): void {.cdecl, importc.}
proc vkGetMemoryFdKHR*(
device: VkDevice;
pGetFdInfo: ptr VkMemoryGetFdInfoKHR;
pFd: ptr int;
): VkResult {.cdecl, importc.}
proc vkGetMemoryFdPropertiesKHR*(
device: VkDevice;
handleType: VkExternalMemoryHandleTypeFlagBits;
fd: int;
pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR;
): VkResult {.cdecl, importc.}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment