Google Git
Sign in
android / platform / tools / gpu / 7f8f7bca7c3d999a35b3007302617ce684dac759 / . / gapid / gfxapi / vulkan / vulkan.api
blob: bc5c50803f2dc49f3ab69a675bd82db9d5c3ec78 [file] [log] [blame]
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Based off of the original vulkan.h header file which has the following
// license.
// Copyright (c) 2015 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and/or associated documentation files (the
// "Materials"), to deal in the Materials without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Materials, and to
// permit persons to whom the Materials are furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Materials.
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
import platform "platform.api"
import "android/vulkan_android.api"
///////////////
// Constants //
///////////////
class ANativeWindow {}
type void* buffer_handle_t
type u32 size_t
// API version (major.minor.patch)
define VERSION_MAJOR 1
define VERSION_MINOR 0
define VERSION_PATCH 3
// API limits
define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
define VK_UUID_SIZE 16
define VK_MAX_EXTENSION_NAME_SIZE 256
define VK_MAX_DESCRIPTION_SIZE 256
define VK_MAX_MEMORY_TYPES 32
define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
// API keywords
define VK_TRUE 1
define VK_FALSE 0
// API keyword, but needs special handling by some templates
define NULL_HANDLE 0
@extension("VK_KHR_surface") define VK_KHR_SURFACE_SPEC_VERSION 25
@extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_SPEC_VERSION 67
@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
@extension("VK_KHR_display") define VK_KHR_DISPLAY_SPEC_VERSION 21
@extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
@extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_SPEC_VERSION 1
@extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
/////////////
// Types //
/////////////
type u32 VkFlags
type u32 VkBool32
type u64 VkDeviceSize
type u32 VkSampleMask
/// Dispatchable handle types.
@dispatchHandle type void* VkInstance
@dispatchHandle type void* VkPhysicalDevice
@dispatchHandle type void* VkDevice
@dispatchHandle type void* VkQueue
@dispatchHandle type void* VkCommandBuffer
/// Non dispatchable handle types.
@nonDispatchHandle type u64 VkSemaphore
@nonDispatchHandle type u64 VkFence
@nonDispatchHandle type u64 VkDeviceMemory
@nonDispatchHandle type u64 VkBuffer
@nonDispatchHandle type u64 VkImage
@nonDispatchHandle type u64 VkEvent
@nonDispatchHandle type u64 VkQueryPool
@nonDispatchHandle type u64 VkBufferView
@nonDispatchHandle type u64 VkImageView
@nonDispatchHandle type u64 VkShaderModule
@nonDispatchHandle type u64 VkPipelineCache
@nonDispatchHandle type u64 VkPipelineLayout
@nonDispatchHandle type u64 VkRenderPass
@nonDispatchHandle type u64 VkPipeline
@nonDispatchHandle type u64 VkDescriptorSetLayout
@nonDispatchHandle type u64 VkSampler
@nonDispatchHandle type u64 VkDescriptorPool
@nonDispatchHandle type u64 VkDescriptorSet
@nonDispatchHandle type u64 VkFramebuffer
@nonDispatchHandle type u64 VkCommandPool
@extension("VK_KHR_surface") @nonDispatchHandle type u64 VkSurfaceKHR
@extension("VK_KHR_swapchain") @nonDispatchHandle type u64 VkSwapchainKHR
@extension("VK_KHR_display") @nonDispatchHandle type u64 VkDisplayKHR
@extension("VK_KHR_display") @nonDispatchHandle type u64 VkDisplayModeKHR
@extension("VK_EXT_debug_report") @nonDispatchHandle type u64 VkDebugReportCallbackEXT
/////////////
// Enums //
/////////////
enum VkPipelineCacheHeaderVersion {
VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
}
@lastUnused(-11)
/// Error and return codes
enum VkResult {
// Return codes for successful operation execution (positive values)
VK_SUCCESS = 0,
VK_NOT_READY = 1,
VK_TIMEOUT = 2,
VK_EVENT_SET = 3,
VK_EVENT_RESET = 4,
VK_INCOMPLETE = 5,
// Error codes (negative values)
VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF, // -1
VK_ERROR_OUT_OF_DEVICE_MEMORY = 0xFFFFFFFE, // -2
VK_ERROR_INITIALIZATION_FAILED = 0xFFFFFFFD, // -3
VK_ERROR_DEVICE_LOST = 0xFFFFFFFC, // -4
VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFFB, // -5
VK_ERROR_LAYER_NOT_PRESENT = 0xFFFFFFFA, // -6
VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9, // -7
VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8, // -8
VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7, // -9
VK_ERROR_TOO_MANY_OBJECTS = 0xFFFFFFF6, // -10
VK_ERROR_FORMAT_NOT_SUPPORTED = 0xFFFFFFF5, // -11
//@extension("VK_KHR_surface")
VK_ERROR_SURFACE_LOST_KHR = 0xC4653600, // -1000000000
//@extension("VK_KHR_surface")
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC46535FF, // -1000008001
//@extension("VK_KHR_swapchain")
VK_SUBOPTIMAL_KHR = 1000001003,
//@extension("VK_KHR_swapchain")
VK_ERROR_OUT_OF_DATE_KHR = 0xC4653214, // -1000001004
//@extension("VK_KHR_display_swapchain")
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC4652A47, // -1000003001
//@extension("VK_EXT_debug_report")
VK_ERROR_VALIDATION_FAILED_EXT = 0xC4650B07, // -1000011001
VK_ERROR_INVALID_SHADER_NV = 0x3B9AF8E0, // -1000012000
}
/// Structure type enumerant
enum VkStructureType {
VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
//@extension("VK_KHR_swapchain")
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
//@extension("VK_KHR_display")
VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
//@extension("VK_KHR_display_swapchain")
VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 1000003000,
//@extension("VK_KHR_xlib_surface")
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
//@extension("VK_KHR_xcb_surface")
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
//@extension("VK_KHR_wayland_surface")
VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
//@extension("VK_KHR_mir_surface")
VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
//@extension("VK_KHR_android_surface")
VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
//@extension("VK_KHR_win32_surface")
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
//@extension("VK_ANDROID_native_buffer")
VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID = 1000010000,
//@extension("VK_EXT_debug_report")
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
}
enum VkSystemAllocationScope {
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0x00000000,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 0x00000001,
VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 0x00000002,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 0x00000003,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 0x00000004,
}
enum VkInternalAllocationType {
VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0x00000000,
}
/// Vulkan format definitions
enum VkFormat {
VK_FORMAT_UNDEFINED = 0,
VK_FORMAT_R4G4_UNORM_PACK8 = 1,
VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
VK_FORMAT_R8_UNORM = 9,
VK_FORMAT_R8_SNORM = 10,
VK_FORMAT_R8_USCALED = 11,
VK_FORMAT_R8_SSCALED = 12,
VK_FORMAT_R8_UINT = 13,
VK_FORMAT_R8_SINT = 14,
VK_FORMAT_R8_SRGB = 15,
VK_FORMAT_R8G8_UNORM = 16,
VK_FORMAT_R8G8_SNORM = 17,
VK_FORMAT_R8G8_USCALED = 18,
VK_FORMAT_R8G8_SSCALED = 19,
VK_FORMAT_R8G8_UINT = 20,
VK_FORMAT_R8G8_SINT = 21,
VK_FORMAT_R8G8_SRGB = 22,
VK_FORMAT_R8G8B8_UNORM = 23,
VK_FORMAT_R8G8B8_SNORM = 24,
VK_FORMAT_R8G8B8_USCALED = 25,
VK_FORMAT_R8G8B8_SSCALED = 26,
VK_FORMAT_R8G8B8_UINT = 27,
VK_FORMAT_R8G8B8_SINT = 28,
VK_FORMAT_R8G8B8_SRGB = 29,
VK_FORMAT_B8G8R8_UNORM = 30,
VK_FORMAT_B8G8R8_SNORM = 31,
VK_FORMAT_B8G8R8_USCALED = 32,
VK_FORMAT_B8G8R8_SSCALED = 33,
VK_FORMAT_B8G8R8_UINT = 34,
VK_FORMAT_B8G8R8_SINT = 35,
VK_FORMAT_B8G8R8_SRGB = 36,
VK_FORMAT_R8G8B8A8_UNORM = 37,
VK_FORMAT_R8G8B8A8_SNORM = 38,
VK_FORMAT_R8G8B8A8_USCALED = 39,
VK_FORMAT_R8G8B8A8_SSCALED = 40,
VK_FORMAT_R8G8B8A8_UINT = 41,
VK_FORMAT_R8G8B8A8_SINT = 42,
VK_FORMAT_R8G8B8A8_SRGB = 43,
VK_FORMAT_B8G8R8A8_UNORM = 44,
VK_FORMAT_B8G8R8A8_SNORM = 45,
VK_FORMAT_B8G8R8A8_USCALED = 46,
VK_FORMAT_B8G8R8A8_SSCALED = 47,
VK_FORMAT_B8G8R8A8_UINT = 48,
VK_FORMAT_B8G8R8A8_SINT = 49,
VK_FORMAT_B8G8R8A8_SRGB = 50,
VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
VK_FORMAT_R16_UNORM = 70,
VK_FORMAT_R16_SNORM = 71,
VK_FORMAT_R16_USCALED = 72,
VK_FORMAT_R16_SSCALED = 73,
VK_FORMAT_R16_UINT = 74,
VK_FORMAT_R16_SINT = 75,
VK_FORMAT_R16_SFLOAT = 76,
VK_FORMAT_R16G16_UNORM = 77,
VK_FORMAT_R16G16_SNORM = 78,
VK_FORMAT_R16G16_USCALED = 79,
VK_FORMAT_R16G16_SSCALED = 80,
VK_FORMAT_R16G16_UINT = 81,
VK_FORMAT_R16G16_SINT = 82,
VK_FORMAT_R16G16_SFLOAT = 83,
VK_FORMAT_R16G16B16_UNORM = 84,
VK_FORMAT_R16G16B16_SNORM = 85,
VK_FORMAT_R16G16B16_USCALED = 86,
VK_FORMAT_R16G16B16_SSCALED = 87,
VK_FORMAT_R16G16B16_UINT = 88,
VK_FORMAT_R16G16B16_SINT = 89,
VK_FORMAT_R16G16B16_SFLOAT = 90,
VK_FORMAT_R16G16B16A16_UNORM = 91,
VK_FORMAT_R16G16B16A16_SNORM = 92,
VK_FORMAT_R16G16B16A16_USCALED = 93,
VK_FORMAT_R16G16B16A16_SSCALED = 94,
VK_FORMAT_R16G16B16A16_UINT = 95,
VK_FORMAT_R16G16B16A16_SINT = 96,
VK_FORMAT_R16G16B16A16_SFLOAT = 97,
VK_FORMAT_R32_UINT = 98,
VK_FORMAT_R32_SINT = 99,
VK_FORMAT_R32_SFLOAT = 100,
VK_FORMAT_R32G32_UINT = 101,
VK_FORMAT_R32G32_SINT = 102,
VK_FORMAT_R32G32_SFLOAT = 103,
VK_FORMAT_R32G32B32_UINT = 104,
VK_FORMAT_R32G32B32_SINT = 105,
VK_FORMAT_R32G32B32_SFLOAT = 106,
VK_FORMAT_R32G32B32A32_UINT = 107,
VK_FORMAT_R32G32B32A32_SINT = 108,
VK_FORMAT_R32G32B32A32_SFLOAT = 109,
VK_FORMAT_R64_UINT = 110,
VK_FORMAT_R64_SINT = 111,
VK_FORMAT_R64_SFLOAT = 112,
VK_FORMAT_R64G64_UINT = 113,
VK_FORMAT_R64G64_SINT = 114,
VK_FORMAT_R64G64_SFLOAT = 115,
VK_FORMAT_R64G64B64_UINT = 116,
VK_FORMAT_R64G64B64_SINT = 117,
VK_FORMAT_R64G64B64_SFLOAT = 118,
VK_FORMAT_R64G64B64A64_UINT = 119,
VK_FORMAT_R64G64B64A64_SINT = 120,
VK_FORMAT_R64G64B64A64_SFLOAT = 121,
VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
VK_FORMAT_D16_UNORM = 124,
VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
VK_FORMAT_D32_SFLOAT = 126,
VK_FORMAT_S8_UINT = 127,
VK_FORMAT_D16_UNORM_S8_UINT = 128,
VK_FORMAT_D24_UNORM_S8_UINT = 129,
VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
VK_FORMAT_BC2_UNORM_BLOCK = 135,
VK_FORMAT_BC2_SRGB_BLOCK = 136,
VK_FORMAT_BC3_UNORM_BLOCK = 137,
VK_FORMAT_BC3_SRGB_BLOCK = 138,
VK_FORMAT_BC4_UNORM_BLOCK = 139,
VK_FORMAT_BC4_SNORM_BLOCK = 140,
VK_FORMAT_BC5_UNORM_BLOCK = 141,
VK_FORMAT_BC5_SNORM_BLOCK = 142,
VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
VK_FORMAT_BC7_UNORM_BLOCK = 145,
VK_FORMAT_BC7_SRGB_BLOCK = 146,
VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
}
enum VkImageType {
VK_IMAGE_TYPE_1D = 0x00000000,
VK_IMAGE_TYPE_2D = 0x00000001,
VK_IMAGE_TYPE_3D = 0x00000002,
}
enum VkImageTiling {
VK_IMAGE_TILING_OPTIMAL = 0x00000000,
VK_IMAGE_TILING_LINEAR = 0x00000001,
}
enum VkPhysicalDeviceType {
VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000,
VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001,
VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002,
VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003,
VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004,
}
enum VkQueryType {
VK_QUERY_TYPE_OCCLUSION = 0x00000000,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional
VK_QUERY_TYPE_TIMESTAMP = 0x00000002,
}
enum VkSharingMode {
VK_SHARING_MODE_EXCLUSIVE = 0x00000000,
VK_SHARING_MODE_CONCURRENT = 0x00000001,
}
enum VkImageLayout {
VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, /// Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
VK_IMAGE_LAYOUT_GENERAL = 0x00000001, /// General layout when image can be used for any kind of access
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, /// Optimal layout when image is only used for color attachment read/write
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, /// Optimal layout when image is only used for depth/stencil attachment read/write
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, /// Optimal layout when image is used for read only depth/stencil attachment and shader access
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, /// Optimal layout when image is used for read only shader access
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU
//@extension("VK_KHR_swapchain")
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
}
enum VkImageViewType {
VK_IMAGE_VIEW_TYPE_1D = 0x00000000,
VK_IMAGE_VIEW_TYPE_2D = 0x00000001,
VK_IMAGE_VIEW_TYPE_3D = 0x00000002,
VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003,
VK_IMAGE_VIEW_TYPE_1D_ARRAY = 0x00000004,
VK_IMAGE_VIEW_TYPE_2D_ARRAY = 0x00000005,
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006,
}
enum VkComponentSwizzle {
VK_COMPONENT_SWIZZLE_IDENTITY = 0x00000000,
VK_COMPONENT_SWIZZLE_ZERO = 0x00000001,
VK_COMPONENT_SWIZZLE_ONE = 0x00000002,
VK_COMPONENT_SWIZZLE_R = 0x00000003,
VK_COMPONENT_SWIZZLE_G = 0x00000004,
VK_COMPONENT_SWIZZLE_B = 0x00000005,
VK_COMPONENT_SWIZZLE_A = 0x00000006,
}
enum VkVertexInputRate {
VK_VERTEX_INPUT_RATE_VERTEX = 0x00000000,
VK_VERTEX_INPUT_RATE_INSTANCE = 0x00000001,
}
enum VkPrimitiveTopology {
VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000,
VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001,
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 0x00000006,
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 0x00000007,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 0x00000008,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 0x00000009,
VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 0x0000000a,
}
enum VkPolygonMode {
VK_POLYGON_MODE_FILL = 0x00000000,
VK_POLYGON_MODE_LINE = 0x00000001,
VK_POLYGON_MODE_POINT = 0x00000002,
}
enum VkFrontFace {
VK_FRONT_FACE_COUNTER_CLOCKWISE = 0x00000000,
VK_FRONT_FACE_CLOCKWISE = 0x00000001,
}
enum VkCompareOp {
VK_COMPARE_OP_NEVER = 0x00000000,
VK_COMPARE_OP_LESS = 0x00000001,
VK_COMPARE_OP_EQUAL = 0x00000002,
VK_COMPARE_OP_LESS_OR_EQUAL = 0x00000003,
VK_COMPARE_OP_GREATER = 0x00000004,
VK_COMPARE_OP_NOT_EQUAL = 0x00000005,
VK_COMPARE_OP_GREATER_OR_EQUAL = 0x00000006,
VK_COMPARE_OP_ALWAYS = 0x00000007,
}
enum VkStencilOp {
VK_STENCIL_OP_KEEP = 0x00000000,
VK_STENCIL_OP_ZERO = 0x00000001,
VK_STENCIL_OP_REPLACE = 0x00000002,
VK_STENCIL_OP_INCREMENT_AND_CLAMP = 0x00000003,
VK_STENCIL_OP_DECREMENT_AND_CLAMP = 0x00000004,
VK_STENCIL_OP_INVERT = 0x00000005,
VK_STENCIL_OP_INCREMENT_AND_WRAP = 0x00000006,
VK_STENCIL_OP_DECREMENT_AND_WRAP = 0x00000007,
}
enum VkLogicOp {
VK_LOGIC_OP_CLEAR = 0x00000000,
VK_LOGIC_OP_AND = 0x00000001,
VK_LOGIC_OP_AND_REVERSE = 0x00000002,
VK_LOGIC_OP_COPY = 0x00000003,
VK_LOGIC_OP_AND_INVERTED = 0x00000004,
VK_LOGIC_OP_NO_OP = 0x00000005,
VK_LOGIC_OP_XOR = 0x00000006,
VK_LOGIC_OP_OR = 0x00000007,
VK_LOGIC_OP_NOR = 0x00000008,
VK_LOGIC_OP_EQUIVALENT = 0x00000009,
VK_LOGIC_OP_INVERT = 0x0000000a,
VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
VK_LOGIC_OP_OR_INVERTED = 0x0000000d,
VK_LOGIC_OP_NAND = 0x0000000e,
VK_LOGIC_OP_SET = 0x0000000f,
}
enum VkBlendFactor {
VK_BLEND_FACTOR_ZERO = 0x00000000,
VK_BLEND_FACTOR_ONE = 0x00000001,
VK_BLEND_FACTOR_SRC_COLOR = 0x00000002,
VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 0x00000003,
VK_BLEND_FACTOR_DST_COLOR = 0x00000004,
VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 0x00000005,
VK_BLEND_FACTOR_SRC_ALPHA = 0x00000006,
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 0x00000007,
VK_BLEND_FACTOR_DST_ALPHA = 0x00000008,
VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 0x00000009,
VK_BLEND_FACTOR_CONSTANT_COLOR = 0x0000000a,
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
VK_BLEND_FACTOR_CONSTANT_ALPHA = 0x0000000c,
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 0x0000000e,
VK_BLEND_FACTOR_SRC1_COLOR = 0x0000000f,
VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 0x00000010,
VK_BLEND_FACTOR_SRC1_ALPHA = 0x00000011,
VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 0x00000012,
}
enum VkBlendOp {
VK_BLEND_OP_ADD = 0x00000000,
VK_BLEND_OP_SUBTRACT = 0x00000001,
VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002,
VK_BLEND_OP_MIN = 0x00000003,
VK_BLEND_OP_MAX = 0x00000004,
}
enum VkDynamicState {
VK_DYNAMIC_STATE_VIEWPORT = 0x00000000,
VK_DYNAMIC_STATE_SCISSOR = 0x00000001,
VK_DYNAMIC_STATE_LINE_WIDTH = 0x00000002,
VK_DYNAMIC_STATE_DEPTH_BIAS = 0x00000003,
VK_DYNAMIC_STATE_BLEND_CONSTANTS = 0x00000004,
VK_DYNAMIC_STATE_DEPTH_BOUNDS = 0x00000005,
VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 0x00000006,
VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 0x00000007,
VK_DYNAMIC_STATE_STENCIL_REFERENCE = 0x00000008,
}
enum VkFilter {
VK_FILTER_NEAREST = 0x00000000,
VK_FILTER_LINEAR = 0x00000001,
VK_FILTER_CUBIC_IMG = 0x3B9B0498
}
enum VkSamplerMipmapMode {
VK_SAMPLER_MIPMAP_MODE_NEAREST = 0x00000000, /// Choose nearest mip level
VK_SAMPLER_MIPMAP_MODE_LINEAR = 0x00000001, /// Linear filter between mip levels
}
enum VkSamplerAddressMode {
VK_SAMPLER_ADDRESS_MODE_REPEAT = 0x00000000,
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 0x00000001,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 0x00000002,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 0x00000003,
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 0x00000004,
}
enum VkBorderColor {
VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0x00000000,
VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 0x00000001,
VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 0x00000002,
VK_BORDER_COLOR_INT_OPAQUE_BLACK = 0x00000003,
VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 0x00000004,
VK_BORDER_COLOR_INT_OPAQUE_WHITE = 0x00000005,
}
enum VkDescriptorType {
VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000,
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001,
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002,
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003,
VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004,
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009,
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 0x0000000a,
}
enum VkAttachmentLoadOp {
VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000,
VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001,
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002,
}
enum VkAttachmentStoreOp {
VK_ATTACHMENT_STORE_OP_STORE = 0x00000000,
VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000001,
}
enum VkPipelineBindPoint {
VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000000,
VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000001,
}
enum VkCommandBufferLevel {
VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0x00000000,
VK_COMMAND_BUFFER_LEVEL_SECONDARY = 0x00000001,
}
enum VkIndexType {
VK_INDEX_TYPE_UINT16 = 0x00000000,
VK_INDEX_TYPE_UINT32 = 0x00000001,
}
enum VkSubpassContents {
VK_SUBPASS_CONTENTS_INLINE = 0x00000000,
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
}
/////////////////
// Bitfields //
/////////////////
@reserved_flags
type VkFlags VkInstanceCreateFlags
/// Format capability flags
bitfield VkFormatFeatureFlagBits {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, /// Format can be used for storage images (STORAGE_IMAGE descriptor type)
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, /// Format supports atomic operations in case it's used for storage images
VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, /// Format can be used for uniform texel buffers (TBOs)
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, /// Format can be used for storage texel buffers (IBOs)
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, /// Format supports atomic operations in case it's used for storage texel buffers
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, /// Format can be used for vertex buffers (VBOs)
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, /// Format can be used for color attachment images
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, /// Format supports blending in case it's used for color attachment images
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, /// Format can be used for depth/stencil attachment images
VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, /// Format can be used as the source image of blits with vkCommandBlitImage
VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, /// Format can be used as the destination image of blits with vkCommandBlitImage
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
}
type VkFlags VkFormatFeatureFlags
/// Image usage flags
bitfield VkImageUsageFlagBits {
VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations
VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations
VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, /// Can be used as storage image (STORAGE_IMAGE descriptor type)
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, /// Can be used as framebuffer color attachment
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, /// Can be used as framebuffer depth/stencil attachment
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, /// Image data not needed outside of rendering
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, /// Can be used as framebuffer input attachment
}
type VkFlags VkImageUsageFlags
/// Image creation flags
bitfield VkImageCreateFlagBits {
VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Image should support sparse backing
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Image should support sparse backing with partial residency
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, /// Allows image views to have different format than the base image
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, /// Allows creating image views with cube type from the created image
}
type VkFlags VkImageCreateFlags
bitfield VkSampleCountFlagBits {
VK_SAMPLE_COUNT_1_BIT = 0x00000001,
VK_SAMPLE_COUNT_2_BIT = 0x00000002,
VK_SAMPLE_COUNT_4_BIT = 0x00000004,
VK_SAMPLE_COUNT_8_BIT = 0x00000008,
VK_SAMPLE_COUNT_16_BIT = 0x00000010,
VK_SAMPLE_COUNT_32_BIT = 0x00000020,
VK_SAMPLE_COUNT_64_BIT = 0x00000040,
}
type VkFlags VkSampleCountFlags
bitfield VkQueueFlagBits {
VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations
VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
VK_QUEUE_TRANSFER_BIT = 0x00000004, /// Queue supports transfer operations
VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
}
type VkFlags VkQueueFlags
bitfield VkMemoryPropertyFlagBits {
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
}
type VkFlags VkMemoryPropertyFlags
bitfield VkMemoryHeapFlagBits {
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
}
type VkFlags VkMemoryHeapFlags
@reserved_flags
type VkFlags VkDeviceCreateFlags
@reserved_flags
type VkFlags VkDeviceQueueCreateFlags
/// Pipeline stages
bitfield VkPipelineStageFlagBits {
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, /// Before subsequent commands are processed
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, /// Draw/DispatchIndirect command fetch
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, /// Vertex/index fetch
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, /// Vertex shading
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, /// Tessellation control shading
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, /// Tessellation evaluation shading
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, /// Geometry shading
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, /// Fragment shading
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, /// Early fragment (depth/stencil) tests
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, /// Late fragment (depth/stencil) tests
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, /// Color attachment writes
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, /// Compute shading
VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, /// Transfer/copy operations
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, /// Indicates host (CPU) is a source/sink of the dependency
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, /// All stages of the graphics pipeline
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, /// All graphics, compute, copy, and transition commands
}
type VkFlags VkPipelineStageFlags
@reserved_flags
type VkFlags VkMemoryMapFlags
bitfield VkImageAspectFlagBits {
VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
}
type VkFlags VkImageAspectFlags
bitfield VkSparseImageFormatFlagBits {
VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices
VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size
}
type VkFlags VkSparseImageFormatFlags
bitfield VkSparseMemoryBindFlagBits {
VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
}
type VkFlags VkSparseMemoryBindFlags
bitfield VkFenceCreateFlagBits {
VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
}
type VkFlags VkFenceCreateFlags
@reserved_flags
type VkFlags VkSemaphoreCreateFlags
@reserved_flags
type VkFlags VkEventCreateFlags
@reserved_flags
type VkFlags VkQueryPoolCreateFlags
bitfield VkQueryPipelineStatisticFlagBits {
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, /// Optional
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, /// Optional
VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, /// Optional
VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, /// Optional
VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, /// Optional
VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, /// Optional
VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, /// Optional
VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, /// Optional
VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, /// Optional
VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, /// Optional
VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, /// Optional
}
type VkFlags VkQueryPipelineStatisticFlags
bitfield VkQueryResultFlagBits {
VK_QUERY_RESULT_64_BIT = 0x00000001, /// Results of the queries are written to the destination buffer as 64-bit values
VK_QUERY_RESULT_WAIT_BIT = 0x00000002, /// Results of the queries are waited on before proceeding with the result copy
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, /// Besides the results of the query, the availability of the results is also written
VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, /// Copy the partial results of the query even if the final results aren't available
}
type VkFlags VkQueryResultFlags
bitfield VkBufferCreateFlagBits {
VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Buffer should support sparse backing
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Buffer should support sparse backing with partial residency
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers
}
type VkFlags VkBufferCreateFlags
type VkFlags VkBufferUsageFlags
bitfield VkBufferUsageFlagBits {
VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations
VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, /// Can be used as IBO
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, /// Can be used as UBO
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, /// Can be used as SSBO
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, /// Can be used as source of fixed function index fetch (index buffer)
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, /// Can be used as source of fixed function vertex fetch (VBO)
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, /// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
}
@reserved_flags
type VkFlags VkBufferViewCreateFlags
@reserved_flags
type VkFlags VkImageViewCreateFlags
@reserved_flags
type VkFlags VkShaderModuleCreateFlags
@reserved_flags
type VkFlags VkPipelineCacheCreateFlags
bitfield VkPipelineCreateFlagBits {
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
}
type VkFlags VkPipelineCreateFlags
@reserved_flags
type VkFlags VkPipelineShaderStageCreateFlags
bitfield VkShaderStageFlagBits {
VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
}
type VkFlags VkShaderStageFlags
@reserved_flags
type VkFlags VkPipelineVertexInputStateCreateFlags
@reserved_flags
type VkFlags VkPipelineInputAssemblyStateCreateFlags
@reserved_flags
type VkFlags VkPipelineTessellationStateCreateFlags
@reserved_flags
type VkFlags VkPipelineViewportStateCreateFlags
@reserved_flags
type VkFlags VkPipelineRasterizationStateCreateFlags
bitfield VkCullModeFlagBits {
VK_CULL_MODE_NONE = 0x00000000,
VK_CULL_MODE_FRONT_BIT = 0x00000001,
VK_CULL_MODE_BACK_BIT = 0x00000002,
VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
}
type VkFlags VkCullModeFlags
@reserved_flags
type VkFlags VkPipelineMultisampleStateCreateFlags
@reserved_flags
type VkFlags VkPipelineDepthStencilStateCreateFlags
@reserved_flags
type VkFlags VkPipelineColorBlendStateCreateFlags
bitfield VkColorComponentFlagBits {
VK_COLOR_COMPONENT_R_BIT = 0x00000001,
VK_COLOR_COMPONENT_G_BIT = 0x00000002,
VK_COLOR_COMPONENT_B_BIT = 0x00000004,
VK_COLOR_COMPONENT_A_BIT = 0x00000008,
}
type VkFlags VkColorComponentFlags
@reserved_flags
type VkFlags VkPipelineDynamicStateCreateFlags
@reserved_flags
type VkFlags VkPipelineLayoutCreateFlags
@reserved_flags
type VkFlags VkSamplerCreateFlags
@reserved_flags
type VkFlags VkDescriptorSetLayoutCreateFlags
bitfield VkDescriptorPoolCreateFlagBits {
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
}
type VkFlags VkDescriptorPoolCreateFlags
@reserved_flags
type VkFlags VkDescriptorPoolResetFlags
@reserved_flags
type VkFlags VkFramebufferCreateFlags
@reserved_flags
type VkFlags VkRenderPassCreateFlags
bitfield VkAttachmentDescriptionFlagBits {
VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, /// The attachment may alias physical memory of another attachment in the same renderpass
}
type VkFlags VkAttachmentDescriptionFlags
@reserved_flags
type VkFlags VkSubpassDescriptionFlags
bitfield VkAccessFlagBits {
VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
VK_ACCESS_INDEX_READ_BIT = 0x00000002,
VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
VK_ACCESS_SHADER_READ_BIT = 0x00000020,
VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
VK_ACCESS_HOST_READ_BIT = 0x00002000,
VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
}
type VkFlags VkAccessFlags
bitfield VkDependencyFlagBits {
VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
}
type VkFlags VkDependencyFlags
bitfield VkCommandPoolCreateFlagBits {
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
}
type VkFlags VkCommandPoolCreateFlags
bitfield VkCommandPoolResetFlagBits {
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
}
type VkFlags VkCommandPoolResetFlags
bitfield VkCommandBufferUsageFlagBits {
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
}
type VkFlags VkCommandBufferUsageFlags
bitfield VkQueryControlFlagBits {
VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
}
type VkFlags VkQueryControlFlags
bitfield VkCommandBufferResetFlagBits {
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
}
type VkFlags VkCommandBufferResetFlags
bitfield VkStencilFaceFlagBits {
VK_STENCIL_FACE_FRONT_BIT = 0x00000001, /// Front face
VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face
VK_STENCIL_FRONT_AND_BACK = 0x00000003,
}
type VkFlags VkStencilFaceFlags
// Function pointers. TODO: add support for function pointers.
@external type void* PFN_vkAllocationFunction
@pfn cmd void* vkAllocationFunction(
void* pUserData,
platform.size_t size,
platform.size_t alignment,
VkSystemAllocationScope allocationScope) {
return ?
}
@external type void* PFN_vkReallocationFunction
@pfn cmd void* vkReallocationFunction(
void* pUserData,
void* pOriginal,
platform.size_t size,
platform.size_t alignment,
VkSystemAllocationScope allocationScope) {
return ?
}
@external type void* PFN_vkFreeFunction
@pfn cmd void vkFreeFunction(
void* pUserData,
void* pMemory) {
}
@external type void* PFN_vkInternalAllocationNotification
@pfn cmd void vkInternalAllocationNotification(
void* pUserData,
platform.size_t size,
VkInternalAllocationType allocationType,
VkSystemAllocationScope allocationScope) {
}
@external type void* PFN_vkInternalFreeNotification
@pfn cmd void vkInternalFreeNotification(
void* pUserData,
platform.size_t size,
VkInternalAllocationType allocationType,
VkSystemAllocationScope allocationScope) {
}
@external type void* PFN_vkVoidFunction
@pfn cmd void vkVoidFunction() {
}
@serialize
class VkApplicationInfo {
VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
const void* pNext /// Next structure in chain
string pApplicationName
u32 applicationVersion
string pEngineName
u32 engineVersion
u32 apiVersion
}
@serialize
class VkInstanceCreateInfo {
VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkInstanceCreateFlags flags
const VkApplicationInfo* pApplicationInfo
u32 enabledLayerCount
string const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
u32 enabledExtensionCount
string* const* ppEnabledExtensionNames /// Extension names to be enabled
}
@serialize
class VkAllocationCallbacks {
void* pUserData
PFN_vkAllocationFunction pfnAllocation
PFN_vkReallocationFunction pfnReallocation
PFN_vkFreeFunction pfnFree
PFN_vkInternalAllocationNotification pfnInternalAllocation
PFN_vkInternalFreeNotification pfnInternalFree
}
@serialize
class VkPhysicalDeviceFeatures {
VkBool32 robustBufferAccess /// out of bounds buffer accesses are well defined
VkBool32 fullDrawIndexUint32 /// full 32-bit range of indices for indexed draw calls
VkBool32 imageCubeArray /// image views which are arrays of cube maps
VkBool32 independentBlend /// blending operations are controlled per-attachment
VkBool32 geometryShader /// geometry stage
VkBool32 tessellationShader /// tessellation control and evaluation stage
VkBool32 sampleRateShading /// per-sample shading and interpolation
VkBool32 dualSrcBlend /// blend operations which take two sources
VkBool32 logicOp /// logic operations
VkBool32 multiDrawIndirect /// multi draw indirect
VkBool32 drawIndirectFirstInstance
VkBool32 depthClamp /// depth clamping
VkBool32 depthBiasClamp /// depth bias clamping
VkBool32 fillModeNonSolid /// point and wireframe fill modes
VkBool32 depthBounds /// depth bounds test
VkBool32 wideLines /// lines with width greater than 1
VkBool32 largePoints /// points with size greater than 1
VkBool32 alphaToOne /// The fragment alpha channel can be forced to maximum representable alpha value
VkBool32 multiViewport
VkBool32 samplerAnisotropy
VkBool32 textureCompressionETC2 /// ETC texture compression formats
VkBool32 textureCompressionASTC_LDR /// ASTC LDR texture compression formats
VkBool32 textureCompressionBC /// BC1-7 texture compressed formats
VkBool32 occlusionQueryPrecise
VkBool32 pipelineStatisticsQuery /// pipeline statistics query
VkBool32 vertexPipelineStoresAndAtomics
VkBool32 fragmentStoresAndAtomics
VkBool32 shaderTessellationAndGeometryPointSize
VkBool32 shaderImageGatherExtended /// texture gather with run-time values and independent offsets
VkBool32 shaderStorageImageExtendedFormats /// the extended set of formats can be used for storage images
VkBool32 shaderStorageImageMultisample /// multisample images can be used for storage images
VkBool32 shaderStorageImageReadWithoutFormat
VkBool32 shaderStorageImageWriteWithoutFormat
VkBool32 shaderUniformBufferArrayDynamicIndexing /// arrays of uniform buffers can be accessed with dynamically uniform indices
VkBool32 shaderSampledImageArrayDynamicIndexing /// arrays of sampled images can be accessed with dynamically uniform indices
VkBool32 shaderStorageBufferArrayDynamicIndexing /// arrays of storage buffers can be accessed with dynamically uniform indices
VkBool32 shaderStorageImageArrayDynamicIndexing /// arrays of storage images can be accessed with dynamically uniform indices
VkBool32 shaderClipDistance /// clip distance in shaders
VkBool32 shaderCullDistance /// cull distance in shaders
VkBool32 shaderFloat64 /// 64-bit floats (doubles) in shaders
VkBool32 shaderInt64 /// 64-bit integers in shaders
VkBool32 shaderInt16 /// 16-bit integers in shaders
VkBool32 shaderResourceResidency /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
VkBool32 shaderResourceMinLod /// shader can use texture operations that specify minimum resource LOD
VkBool32 sparseBinding /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
VkBool32 sparseResidencyBuffer /// Sparse resources support: GPU can access partially resident buffers
VkBool32 sparseResidencyImage2D /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images
VkBool32 sparseResidencyImage3D /// Sparse resources support: GPU can access partially resident 3D images
VkBool32 sparseResidency2Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples
VkBool32 sparseResidency4Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples
VkBool32 sparseResidency8Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
VkBool32 sparseResidency16Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
VkBool32 sparseResidencyAliased /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
VkBool32 variableMultisampleRate
VkBool32 inheritedQueries
}
@serialize
class VkFormatProperties {
VkFormatFeatureFlags linearTilingFeatures /// Format features in case of linear tiling
VkFormatFeatureFlags optimalTilingFeatures /// Format features in case of optimal tiling
VkFormatFeatureFlags bufferFeatures /// Format features supported by buffers
}
@serialize
class VkExtent3D {
u32 width
u32 height
u32 depth
}
@serialize
class VkImageFormatProperties {
VkExtent3D maxExtent /// max image dimensions for this resource type
u32 maxMipLevels /// max number of mipmap levels for this resource type
u32 maxArrayLayers /// max array layers for this resource type
VkSampleCountFlags sampleCounts /// supported sample counts for this resource type
VkDeviceSize maxResourceSize /// max size (in bytes) of this resource type
}
@serialize
class VkPhysicalDeviceLimits {
/// resource maximum sizes
u32 maxImageDimension1D /// max 1D image dimension
u32 maxImageDimension2D /// max 2D image dimension
u32 maxImageDimension3D /// max 3D image dimension
u32 maxImageDimensionCube /// max cubemap image dimension
u32 maxImageArrayLayers /// max layers for image arrays
u32 maxTexelBufferElements
u32 maxUniformBufferRange /// max uniform buffer size (bytes)
u32 maxStorageBufferRange /// max storage buffer size (bytes)
u32 maxPushConstantsSize /// max size of the push constants pool (bytes)
/// memory limits
u32 maxMemoryAllocationCount /// max number of device memory allocations supported
u32 maxSamplerAllocationCount
VkDeviceSize bufferImageGranularity /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
VkDeviceSize sparseAddressSpaceSize /// Total address space available for sparse allocations (bytes)
/// descriptor set limits
u32 maxBoundDescriptorSets /// max number of descriptors sets that can be bound to a pipeline
u32 maxPerStageDescriptorSamplers /// max num of samplers allowed per-stage in a descriptor set
u32 maxPerStageDescriptorUniformBuffers /// max num of uniform buffers allowed per-stage in a descriptor set
u32 maxPerStageDescriptorStorageBuffers /// max num of storage buffers allowed per-stage in a descriptor set
u32 maxPerStageDescriptorSampledImages /// max num of sampled images allowed per-stage in a descriptor set
u32 maxPerStageDescriptorStorageImages /// max num of storage images allowed per-stage in a descriptor set
u32 maxPerStageDescriptorInputAttachments
u32 maxPerStageResources
u32 maxDescriptorSetSamplers /// max num of samplers allowed in all stages in a descriptor set
u32 maxDescriptorSetUniformBuffers /// max num of uniform buffers allowed in all stages in a descriptor set
u32 maxDescriptorSetUniformBuffersDynamic /// max num of dynamic uniform buffers allowed in all stages in a descriptor set
u32 maxDescriptorSetStorageBuffers /// max num of storage buffers allowed in all stages in a descriptor set
u32 maxDescriptorSetStorageBuffersDynamic /// max num of dynamic storage buffers allowed in all stages in a descriptor set
u32 maxDescriptorSetSampledImages /// max num of sampled images allowed in all stages in a descriptor set
u32 maxDescriptorSetStorageImages /// max num of storage images allowed in all stages in a descriptor set
u32 maxDescriptorSetInputAttachments
/// vertex stage limits
u32 maxVertexInputAttributes /// max num of vertex input attribute slots
u32 maxVertexInputBindings /// max num of vertex input binding slots
u32 maxVertexInputAttributeOffset /// max vertex input attribute offset added to vertex buffer offset
u32 maxVertexInputBindingStride /// max vertex input binding stride
u32 maxVertexOutputComponents /// max num of output components written by vertex shader
/// tessellation control stage limits
u32 maxTessellationGenerationLevel /// max level supported by tess primitive generator
u32 maxTessellationPatchSize /// max patch size (vertices)
u32 maxTessellationControlPerVertexInputComponents /// max num of input components per-vertex in TCS
u32 maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
u32 maxTessellationControlPerPatchOutputComponents /// max num of output components per-patch in TCS
u32 maxTessellationControlTotalOutputComponents /// max total num of per-vertex and per-patch output components in TCS
u32 maxTessellationEvaluationInputComponents /// max num of input components per vertex in TES
u32 maxTessellationEvaluationOutputComponents /// max num of output components per vertex in TES
/// geometry stage limits
u32 maxGeometryShaderInvocations /// max invocation count supported in geometry shader
u32 maxGeometryInputComponents /// max num of input components read in geometry stage
u32 maxGeometryOutputComponents /// max num of output components written in geometry stage
u32 maxGeometryOutputVertices /// max num of vertices that can be emitted in geometry stage
u32 maxGeometryTotalOutputComponents /// max total num of components (all vertices) written in geometry stage
/// fragment stage limits
u32 maxFragmentInputComponents /// max num of input compontents read in fragment stage
u32 maxFragmentOutputAttachments /// max num of output attachments written in fragment stage
u32 maxFragmentDualSrcAttachments /// max num of output attachments written when using dual source blending
u32 maxFragmentCombinedOutputResources /// max total num of storage buffers, storage images and output buffers
/// compute stage limits
u32 maxComputeSharedMemorySize /// max total storage size of work group local storage (bytes)
u32[3] maxComputeWorkGroupCount /// max num of compute work groups that may be dispatched by a single command (x,y,z)
u32 maxComputeWorkGroupInvocations /// max total compute invocations in a single local work group
u32[3] maxComputeWorkGroupSize /// max local size of a compute work group (x,y,z)
u32 subPixelPrecisionBits /// num bits of subpixel precision in screen x and y
u32 subTexelPrecisionBits /// num bits of subtexel precision
u32 mipmapPrecisionBits /// num bits of mipmap precision
u32 maxDrawIndexedIndexValue /// max index value for indexed draw calls (for 32-bit indices)
u32 maxDrawIndirectCount
f32 maxSamplerLodBias /// max absolute sampler level of detail bias
f32 maxSamplerAnisotropy /// max degree of sampler anisotropy
u32 maxViewports /// max number of active viewports
u32[2] maxViewportDimensions /// max viewport dimensions (x,y)
f32[2] viewportBoundsRange /// viewport bounds range (min,max)
u32 viewportSubPixelBits /// num bits of subpixel precision for viewport
platform.size_t minMemoryMapAlignment /// min required alignment of pointers returned by MapMemory (bytes)
VkDeviceSize minTexelBufferOffsetAlignment /// min required alignment for texel buffer offsets (bytes)
VkDeviceSize minUniformBufferOffsetAlignment /// min required alignment for uniform buffer sizes and offsets (bytes)
VkDeviceSize minStorageBufferOffsetAlignment /// min required alignment for storage buffer offsets (bytes)
s32 minTexelOffset /// min texel offset for OpTextureSampleOffset
u32 maxTexelOffset /// max texel offset for OpTextureSampleOffset
s32 minTexelGatherOffset /// min texel offset for OpTextureGatherOffset
u32 maxTexelGatherOffset /// max texel offset for OpTextureGatherOffset
f32 minInterpolationOffset /// furthest negative offset for interpolateAtOffset
f32 maxInterpolationOffset /// furthest positive offset for interpolateAtOffset
u32 subPixelInterpolationOffsetBits /// num of subpixel bits for interpolateAtOffset
u32 maxFramebufferWidth /// max width for a framebuffer
u32 maxFramebufferHeight /// max height for a framebuffer
u32 maxFramebufferLayers /// max layer count for a layered framebuffer
VkSampleCountFlags framebufferColorSampleCounts
VkSampleCountFlags framebufferDepthSampleCounts
VkSampleCountFlags framebufferStencilSampleCounts
VkSampleCountFlags framebufferNoAttachmentSampleCounts
u32 maxColorAttachments /// max num of framebuffer color attachments
VkSampleCountFlags sampledImageColorSampleCounts
VkSampleCountFlags sampledImageIntegerSampleCounts
VkSampleCountFlags sampledImageDepthSampleCounts
VkSampleCountFlags sampledImageStencilSampleCounts
VkSampleCountFlags storageImageSampleCounts
u32 maxSampleMaskWords /// max num of sample mask words
VkBool32 timestampComputeAndGraphics
f32 timestampPeriod
u32 maxClipDistances /// max number of clip distances
u32 maxCullDistances /// max number of cull distances
u32 maxCombinedClipAndCullDistances /// max combined number of user clipping
u32 discreteQueuePriorities
f32[2] pointSizeRange /// range (min,max) of supported point sizes
f32[2] lineWidthRange /// range (min,max) of supported line widths
f32 pointSizeGranularity /// granularity of supported point sizes
f32 lineWidthGranularity /// granularity of supported line widths
VkBool32 strictLines
VkBool32 standardSampleLocations
VkDeviceSize optimalBufferCopyOffsetAlignment
VkDeviceSize optimalBufferCopyRowPitchAlignment
VkDeviceSize nonCoherentAtomSize
}
@serialize
class VkPhysicalDeviceSparseProperties {
VkBool32 residencyStandard2DBlockShape /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format)
VkBool32 residencyStandard2DMultisampleBlockShape /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
VkBool32 residencyStandard3DBlockShape /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)
VkBool32 residencyAlignedMipSize /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail
VkBool32 residencyNonResidentStrict /// Sparse resources support: GPU can safely access non-resident regions of a resource, all reads return as if data is 0, writes are discarded
}
@serialize
class VkPhysicalDeviceProperties {
u32 apiVersion
u32 driverVersion
u32 vendorID
u32 deviceID
VkPhysicalDeviceType deviceType
char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName
u8[VK_UUID_SIZE] pipelineCacheUUID
VkPhysicalDeviceLimits limits
VkPhysicalDeviceSparseProperties sparseProperties
}
@serialize
class VkQueueFamilyProperties {
VkQueueFlags queueFlags /// Queue flags
u32 queueCount
u32 timestampValidBits
VkExtent3D minImageTransferGranularity
}
@serialize
class VkMemoryType {
VkMemoryPropertyFlags propertyFlags /// Memory properties of this memory type
u32 heapIndex /// Index of the memory heap allocations of this memory type are taken from
}
@serialize
class VkMemoryHeap {
VkDeviceSize size /// Available memory in the heap
VkMemoryHeapFlags flags /// Flags for the heap
}
@serialize
class VkPhysicalDeviceMemoryProperties {
u32 memoryTypeCount
VkMemoryType[VK_MAX_MEMORY_TYPES] memoryTypes
u32 memoryHeapCount
VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps
}
@serialize
class VkDeviceQueueCreateInfo {
VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkDeviceQueueCreateFlags flags
u32 queueFamilyIndex
u32 queueCount
const f32* pQueuePriorities
}
@serialize
class VkDeviceCreateInfo {
VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkDeviceCreateFlags flags
u32 queueCreateInfoCount
const VkDeviceQueueCreateInfo* pQueueCreateInfos
u32 enabledLayerCount
string const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
u32 enabledExtensionCount
string const* ppEnabledExtensionNames
const VkPhysicalDeviceFeatures* pEnabledFeatures
}
@serialize
class VkExtensionProperties {
char[VK_MAX_EXTENSION_NAME_SIZE] extensionName /// extension name
u32 specVersion /// version of the extension specification implemented
}
@serialize
class VkLayerProperties {
char[VK_MAX_EXTENSION_NAME_SIZE] layerName /// layer name
u32 specVersion /// version of the layer specification implemented
u32 implementationVersion /// build or release version of the layer's library
char[VK_MAX_DESCRIPTION_SIZE] description /// Free-form description of the layer
}
@serialize
class VkSubmitInfo {
VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_SUBMIT_INFO
const void* pNext /// Next structure in chain
u32 waitSemaphoreCount
const VkSemaphore* pWaitSemaphores
const VkPipelineStageFlags* pWaitDstStageMask
u32 commandBufferCount
const VkCommandBuffer* pCommandBuffers
u32 signalSemaphoreCount
const VkSemaphore* pSignalSemaphores
}
@serialize
class VkMemoryAllocateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
const void* pNext /// Pointer to next structure
VkDeviceSize allocationSize /// Size of memory allocation
u32 memoryTypeIndex /// Index of the of the memory type to allocate from
}
@serialize
class VkMappedMemoryRange {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
const void* pNext /// Pointer to next structure
VkDeviceMemory memory /// Mapped memory object
VkDeviceSize offset /// Offset within the mapped memory the range starts from
VkDeviceSize size /// Size of the range within the mapped memory
}
@serialize
class VkMemoryRequirements {
VkDeviceSize size /// Specified in bytes
VkDeviceSize alignment /// Specified in bytes
u32 memoryTypeBits /// Bitfield of the allowed memory type indices into memoryTypes[] for this object
}
@serialize
class VkSparseImageFormatProperties {
VkImageAspectFlagBits aspectMask
VkExtent3D imageGranularity
VkSparseImageFormatFlags flags
}
@serialize
class VkSparseImageMemoryRequirements {
VkSparseImageFormatProperties formatProperties
u32 imageMipTailFirstLod
VkDeviceSize imageMipTailSize /// Specified in bytes, must be a multiple of image block size / alignment
VkDeviceSize imageMipTailOffset /// Specified in bytes, must be a multiple of image block size / alignment
VkDeviceSize imageMipTailStride /// Specified in bytes, must be a multiple of image block size / alignment
}
@serialize
class VkSparseMemoryBind {
VkDeviceSize resourceOffset /// Specified in bytes
VkDeviceSize size /// Specified in bytes
VkDeviceMemory memory
VkDeviceSize memoryOffset /// Specified in bytes
VkSparseMemoryBindFlags flags
}
@serialize
class VkSparseBufferMemoryBindInfo {
VkBuffer buffer
u32 bindCount
const VkSparseMemoryBind* pBinds
}
@serialize
class VkSparseImageOpaqueMemoryBindInfo {
VkImage image
u32 bindCount
const VkSparseMemoryBind* pBinds
}
@serialize
class VkImageSubresource {
VkImageAspectFlagBits aspectMask
u32 mipLevel
u32 arrayLayer
}
@serialize
class VkOffset3D {
s32 x
s32 y
s32 z
}
@serialize
class VkSparseImageMemoryBind {
VkImageSubresource subresource
VkOffset3D offset
VkExtent3D extent
VkDeviceMemory memory
VkDeviceSize memoryOffset /// Specified in bytes
VkSparseMemoryBindFlags flags
}
@serialize
class VkSparseImageMemoryBindInfo {
VkImage image
u32 bindCount
const VkSparseMemoryBind* pBinds
}
@serialize
class VkBindSparseInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
const void* pNext
u32 waitSemaphoreCount
const VkSemaphore* pWaitSemaphores
u32 numBufferBinds
const VkSparseBufferMemoryBindInfo* pBufferBinds
u32 numImageOpaqueBinds
const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds
u32 numImageBinds
const VkSparseImageMemoryBindInfo* pImageBinds
u32 signalSemaphoreCount
const VkSemaphore* pSignalSemaphores
}
@serialize
class VkFenceCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkFenceCreateFlags flags /// Fence creation flags
}
@serialize
class VkSemaphoreCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkSemaphoreCreateFlags flags /// Semaphore creation flags
}
@serialize
class VkEventCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
const void* pNext /// Pointer to next structure
VkEventCreateFlags flags /// Event creation flags
}
@serialize
class VkQueryPoolCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
const void* pNext /// Pointer to next structure
VkQueryPoolCreateFlags flags
VkQueryType queryType
u32 queryCount
VkQueryPipelineStatisticFlags pipelineStatistics /// Optional
}
@serialize
class VkBufferCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
const void* pNext /// Pointer to next structure.
VkBufferCreateFlags flags /// Buffer creation flags
VkDeviceSize size /// Specified in bytes
VkBufferUsageFlags usage /// Buffer usage flags
VkSharingMode sharingMode
u32 queueFamilyIndexCount
const u32* pQueueFamilyIndices
}
@serialize
class VkBufferViewCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
const void* pNext /// Pointer to next structure.
VkBufferViewCreateFlags flags
VkBuffer buffer
VkFormat format /// Optionally specifies format of elements
VkDeviceSize offset /// Specified in bytes
VkDeviceSize range /// View size specified in bytes
}
@serialize
class VkImageCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
const void* pNext /// Pointer to next structure.
VkImageCreateFlags flags /// Image creation flags
VkImageType imageType
VkFormat format
VkExtent3D extent
u32 mipLevels
u32 arrayLayers
VkSampleCountFlagBits samples
VkImageTiling tiling
VkImageUsageFlags usage /// Image usage flags
VkSharingMode sharingMode /// Cross-queue-family sharing mode
u32 queueFamilyIndexCount /// Number of queue families to share across
const u32* pQueueFamilyIndices /// Array of queue family indices to share across
VkImageLayout initialLayout /// Initial image layout for all subresources
}
@serialize
class VkSubresourceLayout {
VkDeviceSize offset /// Specified in bytes
VkDeviceSize size /// Specified in bytes
VkDeviceSize rowPitch /// Specified in bytes
VkDeviceSize arrayPitch /// Specified in bytes
VkDeviceSize depthPitch /// Specified in bytes
}
@serialize
class VkComponentMapping {
VkComponentSwizzle r
VkComponentSwizzle g
VkComponentSwizzle b
VkComponentSwizzle a
}
@serialize
class VkImageSubresourceRange {
VkImageAspectFlags aspectMask
u32 baseMipLevel
u32 levelCount
u32 baseArrayLayer
u32 layerCount
}
@serialize
class VkImageViewCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
const void* pNext /// Pointer to next structure
VkImageViewCreateFlags flags
VkImage image
VkImageViewType viewType
VkFormat format
VkComponentMapping components
VkImageSubresourceRange subresourceRange
}
@serialize
class VkShaderModuleCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkShaderModuleCreateFlags flags /// Reserved
platform.size_t codeSize /// Specified in bytes
const u32* pCode /// Binary code of size codeSize
}
@serialize
class VkPipelineCacheCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineCacheCreateFlags flags
platform.size_t initialDataSize /// Size of initial data to populate cache, in bytes
const void* pInitialData /// Initial data to populate cache
}
@serialize
class VkSpecializationMapEntry {
u32 constantID /// The SpecConstant ID specified in the BIL
u32 offset /// Offset of the value in the data block
platform.size_t size /// Size in bytes of the SpecConstant
}
@serialize
class VkSpecializationInfo {
u32 mapEntryCount /// Number of entries in the map
const VkSpecializationMapEntry* pMapEntries /// Array of map entries
platform.size_t dataSize /// Size in bytes of pData
const void* pData /// Pointer to SpecConstant data
}
@serialize
class VkPipelineShaderStageCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineShaderStageCreateFlags flags
VkShaderStageFlagBits stage
VkShaderModule module
string pName
const VkSpecializationInfo* pSpecializationInfo
}
@serialize
class VkVertexInputBindingDescription {
u32 binding /// Vertex buffer binding id
u32 stride /// Distance between vertices in bytes (0 = no advancement)
VkVertexInputRate inputRate /// Rate at which binding is incremented
}
@serialize
class VkVertexInputAttributeDescription {
u32 location /// location of the shader vertex attrib
u32 binding /// Vertex buffer binding id
VkFormat format /// format of source data
u32 offset /// Offset of first element in bytes from base of vertex
}
@serialize
class VkPipelineVertexInputStateCreateInfo {
VkStructureType sType /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineVertexInputStateCreateFlags flags
u32 vertexBindingDescriptionCount /// number of bindings
const VkVertexInputBindingDescription* pVertexBindingDescriptions
u32 vertexAttributeDescriptionCount /// number of attributes
const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
}
@serialize
class VkPipelineInputAssemblyStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineInputAssemblyStateCreateFlags flags
VkPrimitiveTopology topology
VkBool32 primitiveRestartEnable
}
@serialize
class VkPipelineTessellationStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineTessellationStateCreateFlags flags
u32 patchControlPoints
}
@serialize
class VkViewport {
f32 x
f32 y
f32 width
f32 height
f32 minDepth
f32 maxDepth
}
@serialize
class VkOffset2D {
s32 x
s32 y
}
@serialize
class VkExtent2D {
u32 width
u32 height
}
@serialize
class VkRect2D {
VkOffset2D offset
VkExtent2D extent
}
@serialize
class VkPipelineViewportStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineViewportStateCreateFlags flags
u32 viewportCount
const VkViewport* pViewports
u32 scissorCount
const VkRect2D* pScissors
}
@serialize
class VkPipelineRasterizationStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineRasterizationStateCreateFlags flags
VkBool32 depthClampEnable
VkBool32 rasterizerDiscardEnable
VkPolygonMode polygonMode /// optional (GL45)
VkCullModeFlags cullMode
VkFrontFace frontFace
VkBool32 depthBiasEnable
f32 depthBiasConstantFactor
f32 depthBiasClamp
f32 depthBiasSlopeFactor
f32 lineWidth
}
@serialize
class VkPipelineMultisampleStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineMultisampleStateCreateFlags flags
VkSampleCountFlagBits rasterizationSamples /// Number of samples used for rasterization
VkBool32 sampleShadingEnable /// optional (GL45)
f32 minSampleShading /// optional (GL45)
const VkSampleMask* pSampleMask
VkBool32 alphaToCoverageEnable
VkBool32 alphaToOneEnable
}
@serialize
class VkStencilOpState {
VkStencilOp failOp
VkStencilOp passOp
VkStencilOp depthFailOp
VkCompareOp compareOp
u32 compareMask
u32 writeMask
u32 reference
}
@serialize
class VkPipelineDepthStencilStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineDepthStencilStateCreateFlags flags
VkBool32 depthTestEnable
VkBool32 depthWriteEnable
VkCompareOp depthCompareOp
VkBool32 depthBoundsTestEnable /// optional (depth_bounds_test)
VkBool32 stencilTestEnable
VkStencilOpState front
VkStencilOpState back
f32 minDepthBounds
f32 maxDepthBounds
}
@serialize
class VkPipelineColorBlendAttachmentState {
VkBool32 blendEnable
VkBlendFactor srcColorBlendFactor
VkBlendFactor dstColorBlendFactor
VkBlendOp colorBlendOp
VkBlendFactor srcAlphaBlendFactor
VkBlendFactor dstAlphaBlendFactor
VkBlendOp alphaBlendOp
VkColorComponentFlags colorWriteMask
}
@serialize
class VkPipelineColorBlendStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineColorBlendStateCreateFlags flags
VkBool32 logicOpEnable
VkLogicOp logicOp
u32 attachmentCount /// # of pAttachments
const VkPipelineColorBlendAttachmentState* pAttachments
f32[4] blendConstants
}
@serialize
class VkPipelineDynamicStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineDynamicStateCreateFlags flags
u32 dynamicStateCount
const VkDynamicState* pDynamicStates
}
@serialize
class VkGraphicsPipelineCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineCreateFlags flags /// Pipeline creation flags
u32 stageCount
const VkPipelineShaderStageCreateInfo* pStages /// One entry for each active shader stage
const VkPipelineVertexInputStateCreateInfo* pVertexInputState
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState
const VkPipelineTessellationStateCreateInfo* pTessellationState
const VkPipelineViewportStateCreateInfo* pViewportState
const VkPipelineRasterizationStateCreateInfo* pRasterizationState
const VkPipelineMultisampleStateCreateInfo* pMultisampleState
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState
const VkPipelineColorBlendStateCreateInfo* pColorBlendState
const VkPipelineDynamicStateCreateInfo* pDynamicState
VkPipelineLayout layout /// Interface layout of the pipeline
VkRenderPass renderPass
u32 subpass
VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
}
@serialize
class VkComputePipelineCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineCreateFlags flags /// Pipeline creation flags
VkPipelineShaderStageCreateInfo stage
VkPipelineLayout layout /// Interface layout of the pipeline
VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
}
@serialize
class VkPushConstantRange {
VkShaderStageFlags stageFlags /// Which stages use the range
u32 offset /// Start of the range, in bytes
u32 size /// Length of the range, in bytes
}
@serialize
class VkPipelineLayoutCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineLayoutCreateFlags flags
u32 setLayoutCount /// Number of descriptor sets interfaced by the pipeline
const VkDescriptorSetLayout* pSetLayouts /// Array of <setCount> number of descriptor set layout objects defining the layout of the
u32 pushConstantRangeCount /// Number of push-constant ranges used by the pipeline
const VkPushConstantRange* pPushConstantRanges /// Array of pushConstantRangeCount number of ranges used by various shader stages
}
@serialize
class VkSamplerCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
const void* pNext /// Pointer to next structure
VkSamplerCreateFlags flags
VkFilter magFilter /// Filter mode for magnification
VkFilter minFilter /// Filter mode for minifiation
VkSamplerMipmapMode mipmapMode /// Mipmap selection mode
VkSamplerAddressMode addressModeU
VkSamplerAddressMode addressModeV
VkSamplerAddressMode addressModeW
f32 mipLodBias
VkBool32 anisotropyEnable
f32 maxAnisotropy
VkBool32 compareEnable
VkCompareOp compareOp
f32 minLod
f32 maxLod
VkBorderColor borderColor
VkBool32 unnormalizedCoordinates
}
@serialize
class VkDescriptorSetLayoutBinding {
u32 binding
VkDescriptorType descriptorType /// Type of the descriptors in this binding
u32 descriptorCount /// Number of descriptors in this binding
VkShaderStageFlags stageFlags /// Shader stages this binding is visible to
const VkSampler* pImmutableSamplers /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements)
}
@serialize
class VkDescriptorSetLayoutCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
const void* pNext /// Pointer to next structure
VkDescriptorSetLayoutCreateFlags flags
u32 bindingCount /// Number of bindings in the descriptor set layout
const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings
}
@serialize
class VkDescriptorPoolSize {
VkDescriptorType type
u32 descriptorCount
}
@serialize
class VkDescriptorPoolCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
const void* pNext /// Pointer to next structure
VkDescriptorPoolCreateFlags flags
u32 maxSets
u32 poolSizeCount
const VkDescriptorPoolSize* pPoolSizes
}
@serialize
class VkDescriptorSetAllocateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
const void* pNext /// Pointer to next structure
VkDescriptorPool descriptorPool
u32 descriptorSetCount
const VkDescriptorSetLayout* pSetLayouts
}
@serialize
class VkDescriptorImageInfo {
VkSampler sampler
VkImageView imageView
VkImageLayout imageLayout
}
@serialize
class VkDescriptorBufferInfo {
VkBuffer buffer /// Buffer used for this descriptor when the descriptor is UNIFORM_BUFFER[_DYNAMIC]
VkDeviceSize offset /// Base offset from buffer start in bytes to update in the descriptor set.
VkDeviceSize range /// Size in bytes of the buffer resource for this descriptor update.
}
@serialize
class VkWriteDescriptorSet {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
const void* pNext /// Pointer to next structure
VkDescriptorSet dstSet /// Destination descriptor set
u32 dstBinding /// Binding within the destination descriptor set to write
u32 dstArrayElement /// Array element within the destination binding to write
u32 descriptorCount /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
const VkDescriptorImageInfo* pImageInfo
const VkDescriptorBufferInfo* pBufferInfo
const VkBufferView* pTexelBufferView
}
@serialize
class VkCopyDescriptorSet {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
const void* pNext /// Pointer to next structure
VkDescriptorSet srcSet /// Source descriptor set
u32 srcBinding /// Binding within the source descriptor set to copy from
u32 srcArrayElement /// Array element within the source binding to copy from
VkDescriptorSet dstSet /// Destination descriptor set
u32 dstBinding /// Binding within the destination descriptor set to copy to
u32 dstArrayElement /// Array element within the destination binding to copy to
u32 descriptorCount /// Number of descriptors to copy
}
@serialize
class VkFramebufferCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
const void* pNext /// Pointer to next structure
VkFramebufferCreateFlags flags
VkRenderPass renderPass
u32 attachmentCount
const VkImageView* pAttachments
u32 width
u32 height
u32 layers
}
@serialize
class VkAttachmentDescription {
VkAttachmentDescriptionFlags flags
VkFormat format
VkSampleCountFlagBits samples
VkAttachmentLoadOp loadOp /// Load op for color or depth data
VkAttachmentStoreOp storeOp /// Store op for color or depth data
VkAttachmentLoadOp stencilLoadOp /// Load op for stencil data
VkAttachmentStoreOp stencilStoreOp /// Store op for stencil data
VkImageLayout initialLayout
VkImageLayout finalLayout
}
@serialize
class VkAttachmentReference {
u32 attachment
VkImageLayout layout
}
@serialize
class VkSubpassDescription {
VkSubpassDescriptionFlags flags
VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
u32 inputAttachmentCount
const VkAttachmentReference* pInputAttachments
u32 colorAttachmentCount
const VkAttachmentReference* pColorAttachments
const VkAttachmentReference* pResolveAttachments
const VkAttachmentReference* pDepthStencilAttachment
u32 preserveAttachmentCount
const u32* pPreserveAttachments
}
@serialize
class VkSubpassDependency {
u32 srcSubpass
u32 dstSubpass
VkPipelineStageFlags srcStageMask
VkPipelineStageFlags dstStageMask
VkAccessFlags srcAccessMask
VkAccessFlags dstAccessMask
VkDependencyFlags dependencyFlags
}
@serialize
class VkRenderPassCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
const void* pNext /// Pointer to next structure
VkRenderPassCreateFlags flags
u32 attachmentCount
const VkAttachmentDescription* pAttachments
u32 subpassCount
const VkSubpassDescription* pSubpasses
u32 dependencyCount
const VkSubpassDependency* pDependencies
}
@serialize
class VkCommandPoolCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
const void* pNext /// Pointer to next structure
VkCommandPoolCreateFlags flags /// Command pool creation flags
u32 queueFamilyIndex
}
@serialize
class VkCommandBufferAllocateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
const void* pNext /// Pointer to next structure
VkCommandPool commandPool
VkCommandBufferLevel level
u32 commandBufferCount
}
@serialize
class VkCommandBufferInheritanceInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
const void* pNext /// Pointer to next structure
VkRenderPass renderPass /// Render pass for secondary command buffers
u32 subpass
VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
VkBool32 occlusionQueryEnable
VkQueryControlFlags queryFlags
VkQueryPipelineStatisticFlags pipelineStatistics
}
@serialize
class VkCommandBufferBeginInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
const void* pNext /// Pointer to next structure
VkCommandBufferUsageFlags flags /// Command buffer usage flags
const VkCommandBufferInheritanceInfo* pInheritanceInfo
}
@serialize
class VkBufferCopy {
VkDeviceSize srcOffset /// Specified in bytes
VkDeviceSize dstOffset /// Specified in bytes
VkDeviceSize size /// Specified in bytes
}
@serialize
class VkImageSubresourceLayers {
VkImageAspectFlags aspectMask
u32 mipLevel
u32 baseArrayLayer
u32 layerCount
}
@serialize
class VkImageCopy {
VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images
}
@serialize
class VkImageBlit {
VkImageSubresourceLayers srcSubresource
VkOffset3D[2] srcOffsets
VkImageSubresourceLayers dstSubresource
VkOffset3D[2] dstOffsets
}
@serialize
class VkBufferImageCopy {
VkDeviceSize bufferOffset /// Specified in bytes
u32 bufferRowLength /// Specified in texels
u32 bufferImageHeight
VkImageSubresourceLayers imageSubresource
VkOffset3D imageOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D imageExtent /// Specified in pixels for both compressed and uncompressed images
}
@union
/// Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared.
@serialize
class VkClearColorValue {
f32[4] float32
s32[4] int32
u32[4] uint32
}
@serialize
class VkClearDepthStencilValue {
f32 depth
u32 stencil
}
@union
/// Union allowing specification of color, depth, and stencil color values. Actual value selected is based on attachment being cleared.
@serialize
class VkClearValue {
VkClearColorValue color
VkClearDepthStencilValue depthStencil
}
@serialize
class VkClearAttachment {
VkImageAspectFlags aspectMask
u32 colorAttachment
VkClearValue clearValue
}
@serialize
class VkClearRect {
VkRect2D rect
u32 baseArrayLayer
u32 layerCount
}
@serialize
class VkImageResolve {
VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffset
VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffset
VkExtent3D extent
}
@serialize
class VkMemoryBarrier {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
const void* pNext /// Pointer to next structure.
VkAccessFlags srcAccessMask
VkAccessFlags dstAccessMask
}
@serialize
class VkBufferMemoryBarrier {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
const void* pNext /// Pointer to next structure.
VkAccessFlags srcAccessMask
VkAccessFlags dstAccessMask
u32 srcQueueFamilyIndex /// Queue family to transition ownership from
u32 dstQueueFamilyIndex /// Queue family to transition ownership to
VkBuffer buffer /// Buffer to sync
VkDeviceSize offset /// Offset within the buffer to sync
VkDeviceSize size /// Amount of bytes to sync
}
@serialize
class VkImageMemoryBarrier {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
const void* pNext /// Pointer to next structure.
VkAccessFlags srcAccessMask
VkAccessFlags dstAccessMask
VkImageLayout oldLayout /// Current layout of the image
VkImageLayout newLayout /// New layout to transition the image to
u32 srcQueueFamilyIndex /// Queue family to transition ownership from
u32 dstQueueFamilyIndex /// Queue family to transition ownership to
VkImage image /// Image to sync
VkImageSubresourceRange subresourceRange /// Subresource range to sync
}
@serialize
class VkRenderPassBeginInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
const void* pNext /// Pointer to next structure
VkRenderPass renderPass
VkFramebuffer framebuffer
VkRect2D renderArea
u32 clearValueCount
const VkClearValue* pClearValues
}
@serialize
class VkDispatchIndirectCommand {
u32 x
u32 y
u32 z
}
@serialize
class VkDrawIndexedIndirectCommand {
u32 indexCount
u32 instanceCount
u32 firstIndex
s32 vertexOffset
u32 firstInstance
}
@serialize
class VkDrawIndirectCommand {
u32 vertexCount
u32 instanceCount
u32 firstVertex
u32 firstInstance
}
@threadSafety("system")
@instance
@override
cmd VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance) {
return ?
}
@threadSafety("system")
@instance
@override
cmd void vkDestroyInstance(
VkInstance instance,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@instance
@override
cmd VkResult vkEnumeratePhysicalDevices(
VkInstance instance,
u32* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices) {
return ?
}
@physical_device
cmd void vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures) {
}
@physical_device
cmd void vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties) {
}
@physical_device
cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties) {
return ?
}
@physical_device
cmd void vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties) {
}
@physical_device
cmd void vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
u32* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties) {
}
@physical_device
cmd void vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
}
@instance
@override
cmd PFN_vkVoidFunction vkGetInstanceProcAddr(
VkInstance instance,
string pName) {
return ?
}
@device
@override
cmd PFN_vkVoidFunction vkGetDeviceProcAddr(
VkDevice device,
string pName) {
return ?
}
@threadSafety("system")
@physical_device
@override
cmd VkResult vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice) {
return ?
}
@threadSafety("system")
@device
@override
cmd void vkDestroyDevice(
VkDevice device,
const VkAllocationCallbacks* pAllocator) {
}
@override
cmd VkResult vkEnumerateInstanceExtensionProperties(
string pLayerName,
u32* pPropertyCount,
VkExtensionProperties* pProperties) {
return ?
}
@physical_device
cmd VkResult vkEnumerateDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
string pLayerName,
u32* pPropertyCount,
VkExtensionProperties* pProperties) {
return ?
}
@override
cmd VkResult vkEnumerateInstanceLayerProperties(
u32* pPropertyCount,
VkLayerProperties* pProperties) {
return ?
}
@physical_device
@override
cmd VkResult vkEnumerateDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
u32* pPropertyCount,
VkLayerProperties* pProperties) {
return ?
}
@threadSafety("system")
@device
@override
cmd void vkGetDeviceQueue(
VkDevice device,
u32 queueFamilyIndex,
u32 queueIndex,
VkQueue* pQueue) {
}
@threadSafety("app")
@queue
cmd VkResult vkQueueSubmit(
VkQueue queue,
u32 submitCount,
const VkSubmitInfo* pSubmits,
VkFence fence) {
return ?
}
@threadSafety("system")
@queue
cmd VkResult vkQueueWaitIdle(
VkQueue queue) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkDeviceWaitIdle(
VkDevice device) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkAllocateMemory(
VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory) {
return ?
}
@threadSafety("system")
@device
cmd void vkFreeMemory(
VkDevice device,
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("app")
@device
cmd VkResult vkMapMemory(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData) {
return ?
}
@threadSafety("app")
@device
cmd void vkUnmapMemory(
VkDevice device,
VkDeviceMemory memory) {
}
@device
cmd VkResult vkFlushMappedMemoryRanges(
VkDevice device,
u32 memoryRangeCount
const VkMappedMemoryRange* pMemoryRanges) {
return ?
}
@device
cmd VkResult vkInvalidateMappedMemoryRanges(
VkDevice device,
u32 memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
return ?
}
// Memory management API functions
@device
cmd void vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes) {
}
@device
cmd VkResult vkBindBufferMemory(
VkDevice device,
VkBuffer buffer,
VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
return ?
}
@device
cmd VkResult vkBindImageMemory(
VkDevice device,
VkImage image,
VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
return ?
}
@device
cmd void vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements) {
}
@device
cmd void vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements) {
}
@device
cmd void vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
u32* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
}
@physical_device
cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkSampleCountFlagBits samples,
VkImageUsageFlags usage,
VkImageTiling tiling,
u32* pPropertyCount,
VkSparseImageFormatProperties* pProperties) {
}
@queue
cmd VkResult vkQueueBindSparse(
VkQueue queue,
u32 bindInfoCount,
const VkBindSparseInfo* pBindInfo,
VkFence fence) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyFence(
VkDevice device,
VkFence fence,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkResetFences(
VkDevice device,
u32 fenceCount,
const VkFence* pFences) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkGetFenceStatus(
VkDevice device,
VkFence fence) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkWaitForFences(
VkDevice device,
u32 fenceCount,
const VkFence* pFences,
VkBool32 waitAll,
u64 timeout) { /// timeout in nanoseconds
return ?
}
@threadSafety("system")
@device
cmd VkResult vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyEvent(
VkDevice device,
VkEvent event,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkGetEventStatus(
VkDevice device,
VkEvent event) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkSetEvent(
VkDevice device,
VkEvent event) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkResetEvent(
VkDevice device,
VkEvent event) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkGetQueryPoolResults(
VkDevice device,
VkQueryPool queryPool,
u32 firstQuery,
u32 queryCount,
platform.size_t dataSize,
void* pData,
VkDeviceSize stride,
VkQueryResultFlags flags) {
return ?
}
@threadSafety("system")
@device
cmd VkResult vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyBuffer(
VkDevice device,
VkBuffer buffer,
const VkAllocationCallbacks* pAllocator) {
}
// Buffer view functions
@threadSafety("system")
@device
cmd VkResult vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBufferView* pView) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImage* pImage) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyImage(
VkDevice device,
VkImage image,
const VkAllocationCallbacks* pAllocator) {
}
@device
cmd void vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImageView* pView) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyImageView(
VkDevice device,
VkImageView imageView,
const VkAllocationCallbacks* pAllocator) {
}
@device
cmd VkResult vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule) {
return ?
}
@device
cmd void vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator) {
}
@device
cmd VkResult vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache) {
return ?
}
@device
cmd void vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator) {
}
@device
cmd VkResult vkGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
platform.size_t* pDataSize,
void* pData) {
return ?
}
@device
cmd VkResult vkMergePipelineCaches(
VkDevice device,
VkPipelineCache dstCache,
u32 srcCacheCount,
const VkPipelineCache* pSrcCaches) {
return ?
}
@device
cmd VkResult vkCreateGraphicsPipelines(
VkDevice device,
VkPipelineCache pipelineCache,
u32 createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
return ?
}
@device
cmd VkResult vkCreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
u32 createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroySampler(
VkDevice device,
VkSampler sampler,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("app")
@device
cmd VkResult vkResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags) {
return ?
}
@threadSafety("app")
@device
cmd VkResult vkAllocateDescriptorSets(
VkDevice device,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets) {
return ?
}
@device
cmd VkResult vkFreeDescriptorSets(
VkDevice device,
VkDescriptorPool descriptorPool,
u32 descriptorSetCount,
const VkDescriptorSet* pDescriptorSets) {
return ?
}
@device
cmd void vkUpdateDescriptorSets(
VkDevice device,
u32 descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
u32 descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator) {
}
@threadSafety("system")
@device
cmd VkResult vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
return ?
}
@threadSafety("system")
@device
cmd void vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator) {
}
@device
cmd void vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity) {
}
@device
cmd VkResult vkCreateCommandPool(
VkDevice device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool) {
return ?
}
@device
cmd void vkDestroyCommandPool(
VkDevice device,
VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator) {
}
@device
cmd VkResult vkResetCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolResetFlags flags) {
return ?
}
@threadSafety("system")
@device
@override
cmd VkResult vkAllocateCommandBuffers(
VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers) {
return ?
}
@threadSafety("system")
@device
cmd void vkFreeCommandBuffers(
VkDevice device,
VkCommandPool commandPool,
u32 commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
}
@threadSafety("app")
@command_buffer
cmd VkResult vkBeginCommandBuffer(
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo) {
return ?
}
@threadSafety("app")
@command_buffer
cmd VkResult vkEndCommandBuffer(
VkCommandBuffer commandBuffer) {
commandBufferObject := GetCommandBuffer(commandBuffer)
return ?
}
@threadSafety("app")
@command_buffer
cmd VkResult vkResetCommandBuffer(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags) {
return ?
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBindPipeline(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetViewport(
VkCommandBuffer commandBuffer,
u32 firstViewport,
u32 viewportCount,
const VkViewport* pViewports) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetScissor(
VkCommandBuffer commandBuffer,
u32 firstScissor,
u32 scissorCount,
const VkRect2D* pScissors) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetLineWidth(
VkCommandBuffer commandBuffer,
f32 lineWidth) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetDepthBias(
VkCommandBuffer commandBuffer,
f32 depthBiasConstantFactor,
f32 depthBiasClamp,
f32 depthBiasSlopeFactor) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetBlendConstants(
VkCommandBuffer commandBuffer,
// TODO(jessehall): apic only supports 'const' on pointer types. Using
// an annotation as a quick hack to pass this to the template without
// having to modify the AST and semantic model.
@readonly f32[4] blendConstants) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetDepthBounds(
VkCommandBuffer commandBuffer,
f32 minDepthBounds,
f32 maxDepthBounds) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
u32 compareMask) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
u32 writeMask) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
u32 reference) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBindDescriptorSets(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
u32 firstSet,
u32 descriptorSetCount,
const VkDescriptorSet* pDescriptorSets,
u32 dynamicOffsetCount,
const u32* pDynamicOffsets) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBindIndexBuffer(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBindVertexBuffers(
VkCommandBuffer commandBuffer,
u32 firstBinding,
u32 bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdDraw(
VkCommandBuffer commandBuffer,
u32 vertexCount,
u32 instanceCount,
u32 firstVertex,
u32 firstInstance) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdDrawIndexed(
VkCommandBuffer commandBuffer,
u32 indexCount,
u32 instanceCount,
u32 firstIndex,
s32 vertexOffset,
u32 firstInstance) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdDrawIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
u32 drawCount,
u32 stride) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdDrawIndexedIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
u32 drawCount,
u32 stride) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdDispatch(
VkCommandBuffer commandBuffer,
u32 x,
u32 y,
u32 z) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdDispatchIndirect(
VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdCopyBuffer(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
u32 regionCount,
const VkBufferCopy* pRegions) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdCopyImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
u32 regionCount,
const VkImageCopy* pRegions) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
u32 regionCount,
const VkImageBlit* pRegions,
VkFilter filter) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
u32 regionCount,
const VkBufferImageCopy* pRegions) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
u32 regionCount,
const VkBufferImageCopy* pRegions) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdUpdateBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const u32* pData) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdFillBuffer(
VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize size,
u32 data) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
u32 rangeCount,
const VkImageSubresourceRange* pRanges) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
u32 rangeCount,
const VkImageSubresourceRange* pRanges) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdClearAttachments(
VkCommandBuffer commandBuffer,
u32 attachmentCount,
const VkClearAttachment* pAttachments,
u32 rectCount,
const VkClearRect* pRects) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
u32 regionCount,
const VkImageResolve* pRegions) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdSetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdResetEvent(
VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdWaitEvents(
VkCommandBuffer commandBuffer,
u32 eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
u32 memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
u32 bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
u32 imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
u32 memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
u32 bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
u32 imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 query,
VkQueryControlFlags flags) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 query) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 firstQuery,
u32 queryCount) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdWriteTimestamp(
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
u32 query) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 firstQuery,
u32 queryCount,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags) {
}
@command_buffer
cmd void vkCmdPushConstants(
VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
u32 offset,
u32 size,
const void* pValues) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents) {
}
@command_buffer
cmd void vkCmdNextSubpass(
VkCommandBuffer commandBuffer,
VkSubpassContents contents) {
}
@threadSafety("app")
@command_buffer
cmd void vkCmdEndRenderPass(
VkCommandBuffer commandBuffer) {
}
@command_buffer
cmd void vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
u32 commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
}
// ----------------------------------------------------------------------------
// VK_KHR_surface
// ----------------------------------------------------------------------------
@extension("VK_KHR_surface")
enum VkColorSpaceKHR {
VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000,
}
@extension("VK_KHR_surface")
enum VkPresentModeKHR {
VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
VK_PRESENT_MODE_MAILBOX_KHR = 0x00000001,
VK_PRESENT_MODE_FIFO_KHR = 0x00000002,
VK_PRESENT_MODE_FIFO_RELAXED_KHR = 0x00000003,
}
@extension("VK_KHR_surface")
bitfield VkSurfaceTransformFlagBitsKHR {
VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
}
@extension("VK_KHR_surface")
type VkFlags VkSurfaceTransformFlagsKHR
@extension("VK_KHR_surface")
bitfield VkCompositeAlphaFlagBitsKHR {
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
}
@extension("VK_KHR_surface")
type VkFlags VkCompositeAlphaFlagsKHR
@extension("VK_KHR_surface")
@serialize
class VkSurfaceCapabilitiesKHR {
u32 minImageCount
u32 maxImageCount
VkExtent2D currentExtent
VkExtent2D minImageExtent
VkExtent2D maxImageExtent
u32 maxImageArrayLayers
VkSurfaceTransformFlagsKHR supportedTransforms
VkSurfaceTransformFlagBitsKHR currentTransform
VkCompositeAlphaFlagsKHR supportedCompositeAlpha
VkImageUsageFlags supportedUsageFlags
}
@extension("VK_KHR_surface")
@serialize
class VkSurfaceFormatKHR {
VkFormat format
VkColorSpaceKHR colorSpace
}
@extension("VK_KHR_surface")
@instance
cmd void vkDestroySurfaceKHR(
VkInstance instance,
VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator) {
}
@extension("VK_KHR_surface")
@physical_device
cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice,
u32 queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32* pSupported) {
return ?
}
@extension("VK_KHR_surface")
@physical_device
cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
return ?
}
@extension("VK_KHR_surface")
@physical_device
cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
u32* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats) {
return ?
}
@extension("VK_KHR_surface")
@physical_device
cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
u32* pPresentModeCount,
VkPresentModeKHR* pPresentModes) {
return ?
}
// ----------------------------------------------------------------------------
// VK_KHR_swapchain
// ----------------------------------------------------------------------------
@extension("VK_KHR_swapchain")
@reserved_flags
type VkFlags VkSwapchainCreateFlagsKHR
@extension("VK_KHR_swapchain")
@serialize
class VkSwapchainCreateInfoKHR {
VkStructureType sType
const void* pNext
VkSwapchainCreateFlagsKHR flags
VkSurfaceKHR surface
u32 minImageCount
VkFormat imageFormat
VkColorSpaceKHR imageColorSpace
VkExtent2D imageExtent
u32 imageArrayLayers
VkImageUsageFlags imageUsage
VkSharingMode imageSharingMode
u32 queueFamilyIndexCount
const u32* pQueueFamilyIndices
VkSurfaceTransformFlagBitsKHR preTransform
VkCompositeAlphaFlagBitsKHR compositeAlpha
VkPresentModeKHR presentMode
VkBool32 clipped
VkSwapchainKHR oldSwapchain
}
@extension("VK_KHR_swapchain")
@serialize
class VkPresentInfoKHR {
VkStructureType sType
const void* pNext
u32 waitSemaphoreCount
const VkSemaphore* pWaitSemaphores
u32 swapchainCount
const VkSwapchainKHR* pSwapchains
const u32* pImageIndices
VkResult* pResults
}
@extension("VK_KHR_swapchain")
@device
cmd VkResult vkCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain) {
return ?
}
@extension("VK_KHR_swapchain")
@device
cmd void vkDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator) {
}
@extension("VK_KHR_swapchain")
@device
cmd VkResult vkGetSwapchainImagesKHR(
VkDevice device,
VkSwapchainKHR swapchain,
u32* pSwapchainImageCount,
VkImage* pSwapchainImages) {
return ?
}
@extension("VK_KHR_swapchain")
@device
cmd VkResult vkAcquireNextImageKHR(
VkDevice device,
VkSwapchainKHR swapchain,
u64 timeout,
VkSemaphore semaphore,
VkFence fence,
u32* pImageIndex) {
return ?
}
@extension("VK_KHR_swapchain")
@queue
cmd VkResult vkQueuePresentKHR(
VkQueue queue,
const VkPresentInfoKHR* pPresentInfo) {
return ?
}
// ----------------------------------------------------------------------------
// VK_KHR_display
// ----------------------------------------------------------------------------
@extension("VK_KHR_display")
bitfield VkDisplayPlaneAlphaFlagBitsKHR {
VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
}
@extension("VK_KHR_display")
type VkFlags VkDisplayPlaneAlphaFlagsKHR
@extension("VK_KHR_display")
@reserved_flags
type VkFlags VkDisplayModeCreateFlagsKHR
@extension("VK_KHR_display")
@reserved_flags
type VkFlags VkDisplaySurfaceCreateFlagsKHR
@extension("VK_KHR_display")
@serialize
class VkDisplayPropertiesKHR {
VkDisplayKHR display
string displayName
VkExtent2D physicalDimensions
VkExtent2D physicalResolution
VkSurfaceTransformFlagsKHR supportedTransforms
VkBool32 planeReorderPossible
VkBool32 persistentContent
}
@extension("VK_KHR_display")
@serialize
class VkDisplayModeParametersKHR {
VkExtent2D visibleRegion
u32 refreshRate
}
@extension("VK_KHR_display")
@serialize
class VkDisplayModePropertiesKHR {
VkDisplayModeKHR displayMode
VkDisplayModeParametersKHR parameters
}
@extension("VK_KHR_display")
@serialize
class VkDisplayModeCreateInfoKHR {
VkStructureType sType
const void* pNext
VkDisplayModeCreateFlagsKHR flags
VkDisplayModeParametersKHR parameters
}
@extension("VK_KHR_display")
@serialize
class VkDisplayPlaneCapabilitiesKHR {
VkDisplayPlaneAlphaFlagsKHR supportedAlpha
VkOffset2D minSrcPosition
VkOffset2D maxSrcPosition
VkExtent2D minSrcExtent
VkExtent2D maxSrcExtent
VkOffset2D minDstPosition
VkOffset2D maxDstPosition
VkExtent2D minDstExtent
VkExtent2D maxDstExtent
}
@extension("VK_KHR_display")
@serialize
class VkDisplayPlanePropertiesKHR {
VkDisplayKHR currentDisplay
u32 currentStackIndex
}
@extension("VK_KHR_display")
@serialize
class VkDisplaySurfaceCreateInfoKHR {
VkStructureType sType
const void* pNext
VkDisplaySurfaceCreateFlagsKHR flags
VkDisplayModeKHR displayMode
u32 planeIndex
u32 planeStackIndex
VkSurfaceTransformFlagBitsKHR transform
f32 globalAlpha
VkDisplayPlaneAlphaFlagBitsKHR alphaMode
VkExtent2D imageExtent
}
@extension("VK_KHR_display")
@physical_device
cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
VkPhysicalDevice physicalDevice,
u32* pPropertyCount,
VkDisplayPropertiesKHR* pProperties) {
return ?
}
@extension("VK_KHR_display")
@physical_device
cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice,
u32* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties) {
return ?
}
@extension("VK_KHR_display")
@physical_device
cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
u32 planeIndex,
u32* pDisplayCount,
VkDisplayKHR* pDisplays) {
return ?
}
@extension("VK_KHR_display")
@physical_device
cmd VkResult vkGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
u32* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties) {
return ?
}
@extension("VK_KHR_display")
@physical_device
cmd VkResult vkCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode) {
return ?
}
@extension("VK_KHR_display")
@physical_device
cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
u32 planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
return ?
}
@extension("VK_KHR_display")
@instance
cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
return ?
}
// ----------------------------------------------------------------------------
// VK_KHR_display_swapchain
// ----------------------------------------------------------------------------
@extension("VK_KHR_display_swapchain")
@serialize
class VkDisplayPresentInfoKHR {
VkStructureType sType
const void* pNext
VkRect2D srcRect
VkRect2D dstRect
VkBool32 persistent
}
@extension("VK_KHR_display_swapchain")
@device
cmd VkResult vkCreateSharedSwapchainsKHR(
VkDevice device,
u32 swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchains) {
return ?
}
// ----------------------------------------------------------------------------
// VK_EXT_debug_report
// ----------------------------------------------------------------------------
@extension("VK_EXT_debug_report")
enum VkDebugReportObjectTypeEXT {
VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
}
@extension("VK_EXT_debug_report")
enum VkDebugReportErrorEXT {
VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
}
@extension("VK_EXT_debug_report")
bitfield VkDebugReportFlagBitsEXT {
VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
}
@extension("VK_EXT_debug_report")
type VkFlags VkDebugReportFlagsEXT
@extension("VK_EXT_debug_report")
@external type void* PFN_vkDebugReportCallbackEXT
@extension("VK_EXT_debug_report")
@pfn cmd VkBool32 vkDebugReportCallbackEXT(
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
u64 object,
platform.size_t location,
s32 messageCode,
string pLayerPrefix,
string pMessage,
void* pUserData) {
return ?
}
@extension("VK_EXT_debug_report")
@serialize
class VkDebugReportCallbackCreateInfoEXT {
VkStructureType sType
const void* pNext
VkDebugReportFlagsEXT flags
PFN_vkDebugReportCallbackEXT pfnCallback
void* pUserData
}
@extension("VK_EXT_debug_report")
@instance
cmd VkResult vkCreateDebugReportCallbackEXT(
VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDebugReportCallbackEXT* pCallback) {
return ?
}
@extension("VK_EXT_debug_report")
@instance
cmd void vkDestroyDebugReportCallbackEXT(
VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* pAllocator) {
}
@extension("VK_EXT_debug_report")
@instance
cmd void vkDebugReportMessageEXT(
VkInstance instance,
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
u64 object,
platform.size_t location,
s32 messageCode,
string pLayerPrefix,
string pMessage) {
}
extern void validate(string layerName, bool condition, string message)
/////////////////////////////
// Internal State Tracking //
/////////////////////////////
StateObject State
@internal class StateObject {
// Dispatchable objects.
map!(VkInstance, ref!InstanceObject) Instances
map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices
map!(VkDevice, ref!DeviceObject) Devices
map!(VkQueue, ref!QueueObject) Queues
map!(VkCommandBuffer, ref!CommandBufferObject) CommandBuffers
// Non-dispatchable objects.
map!(VkDeviceMemory, ref!DeviceMemoryObject) DeviceMemories
map!(VkBuffer, ref!BufferObject) Buffers
map!(VkBufferView, ref!BufferViewObject) BufferViews
map!(VkImage, ref!ImageObject) Images
map!(VkImageView, ref!ImageViewObject) ImageViews
map!(VkShaderModule, ref!ShaderModuleObject) ShaderModules
map!(VkPipeline, ref!PipelineObject) Pipelines
map!(VkPipelineLayout, ref!PipelineLayoutObject) PipelineLayouts
map!(VkSampler, ref!SamplerObject) Samplers
map!(VkDescriptorSet, ref!DescriptorSetObject) DescriptorSets
map!(VkDescriptorSetLayout, ref!DescriptorSetLayoutObject) DescriptorSetLayouts
map!(VkDescriptorPool, ref!DescriptorPoolObject) DescriptorPools
map!(VkFence, ref!FenceObject) Fences
map!(VkSemaphore, ref!SemaphoreObject) Semaphores
map!(VkEvent, ref!EventObject) Events
map!(VkQueryPool, ref!QueryPoolObject) QueryPools
map!(VkFramebuffer, ref!FramebufferObject) Framebuffers
map!(VkRenderPass, ref!RenderPassObject) RenderPasses
map!(VkPipelineCache, ref!PipelineCacheObject) PipelineCaches
map!(VkCommandPool, ref!CommandPoolObject) CommandPools
map!(VkSurfaceKHR, ref!SurfaceObject) Surfaces
map!(VkSwapchainKHR, ref!SwapchainObject) Swapchains
}
@internal class InstanceObject {
}
@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6
@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_SPEC_VERSION 6
@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
@internal class PhysicalDeviceObject {
VkInstance instance
}
@internal class DeviceObject {
VkPhysicalDevice physicalDevice
}
@internal class QueueObject {
VkDevice device
VkQueueFlags flags
}
@internal class CommandBufferObject {
VkDevice device
map!(u64, VkDeviceMemory) boundObjects
VkQueueFlags queueFlags
}
@internal class DeviceMemoryObject {
VkDevice device
VkDeviceSize allocationSize
map!(u64, VkDeviceSize) boundObjects
map!(VkCommandBuffer, VkCommandBuffer) boundCommandBuffers
}
@internal class BufferObject {
VkDevice device
VkDeviceMemory memory
VkDeviceSize memoryOffset
}
@internal class BufferViewObject {
VkDevice device
VkBuffer buffer
}
@internal class ImageObject {
VkDevice device
VkDeviceMemory memory
VkDeviceSize memoryOffset
}
@internal class ImageViewObject {
VkDevice device
VkImage image
}
@internal class ShaderObject {
VkDevice device
}
@internal class ShaderModuleObject {
VkDevice device
}
@internal class PipelineObject {
VkDevice device
}
@internal class PipelineLayoutObject {
VkDevice device
}
@internal class SamplerObject {
VkDevice device
}
@internal class DescriptorSetObject {
VkDevice device
}
@internal class DescriptorSetLayoutObject {
VkDevice device
}
@internal class DescriptorPoolObject {
VkDevice device
}
@internal class FenceObject {
VkDevice device
bool signaled
}
@internal class SemaphoreObject {
VkDevice device
}
@internal class EventObject {
VkDevice device
}
@internal class QueryPoolObject {
VkDevice device
}
@internal class FramebufferObject {
VkDevice device
}
@internal class RenderPassObject {
VkDevice device
}
@internal class PipelineCacheObject {
VkDevice device
}
@internal class CommandPoolObject {
VkDevice device
}
@internal class SurfaceObject {
VkInstance instance
}
@internal class SwapchainObject {
VkDevice device
}
macro ref!InstanceObject GetInstance(VkInstance instance) {
assert(instance in State.Instances)
return State.Instances[instance]
}
macro ref!PhysicalDeviceObject GetPhysicalDevice(VkPhysicalDevice physicalDevice) {
assert(physicalDevice in State.PhysicalDevices)
return State.PhysicalDevices[physicalDevice]
}
macro ref!DeviceObject GetDevice(VkDevice device) {
assert(device in State.Devices)
return State.Devices[device]
}
macro ref!QueueObject GetQueue(VkQueue queue) {
assert(queue in State.Queues)
return State.Queues[queue]
}
macro ref!CommandBufferObject GetCommandBuffer(VkCommandBuffer commandBuffer) {
assert(commandBuffer in State.CommandBuffers)
return State.CommandBuffers[commandBuffer]
}
macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory memory) {
assert(memory in State.DeviceMemories)
return State.DeviceMemories[memory]
}
macro ref!BufferObject GetBuffer(VkBuffer buffer) {
assert(buffer in State.Buffers)
return State.Buffers[buffer]
}
macro ref!BufferViewObject GetBufferView(VkBufferView bufferView) {
assert(bufferView in State.BufferViews)
return State.BufferViews[bufferView]
}
macro ref!ImageObject GetImage(VkImage image) {
assert(image in State.Images)
return State.Images[image]
}
macro ref!ImageViewObject GetImageView(VkImageView imageView) {
assert(imageView in State.ImageViews)
return State.ImageViews[imageView]
}
macro ref!ShaderModuleObject GetShaderModule(VkShaderModule shaderModule) {
assert(shaderModule in State.ShaderModules)
return State.ShaderModules[shaderModule]
}
macro ref!PipelineObject GetPipeline(VkPipeline pipeline) {
assert(pipeline in State.Pipelines)
return State.Pipelines[pipeline]
}
macro ref!PipelineLayoutObject GetPipelineLayout(VkPipelineLayout pipelineLayout) {
assert(pipelineLayout in State.PipelineLayouts)
return State.PipelineLayouts[pipelineLayout]
}
macro ref!SamplerObject GetSampler(VkSampler sampler) {
assert(sampler in State.Samplers)
return State.Samplers[sampler]
}
macro ref!DescriptorSetObject GetDescriptorSet(VkDescriptorSet descriptorSet) {
assert(descriptorSet in State.DescriptorSets)
return State.DescriptorSets[descriptorSet]
}
macro ref!DescriptorSetLayoutObject GetDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) {
assert(descriptorSetLayout in State.DescriptorSetLayouts)
return State.DescriptorSetLayouts[descriptorSetLayout]
}
macro ref!DescriptorPoolObject GetDescriptorPool(VkDescriptorPool descriptorPool) {
assert(descriptorPool in State.DescriptorPools)
return State.DescriptorPools[descriptorPool]
}
macro ref!FenceObject GetFence(VkFence fence) {
assert(fence in State.Fences)
return State.Fences[fence]
}
macro ref!SemaphoreObject GetSemaphore(VkSemaphore semaphore) {
assert(semaphore in State.Semaphores)
return State.Semaphores[semaphore]
}
macro ref!EventObject GetEvent(VkEvent event) {
assert(event in State.Events)
return State.Events[event]
}
macro ref!QueryPoolObject GetQueryPool(VkQueryPool queryPool) {
assert(queryPool in State.QueryPools)
return State.QueryPools[queryPool]
}
macro ref!FramebufferObject GetFramebuffer(VkFramebuffer framebuffer) {
assert(framebuffer in State.Framebuffers)
return State.Framebuffers[framebuffer]
}
macro ref!RenderPassObject GetRenderPass(VkRenderPass renderPass) {
assert(renderPass in State.RenderPasses)
return State.RenderPasses[renderPass]
}
macro ref!PipelineCacheObject GetPipelineCache(VkPipelineCache pipelineCache) {
assert(pipelineCache in State.PipelineCaches)
return State.PipelineCaches[pipelineCache]
}
macro ref!CommandPoolObject GetCommandPool(VkCommandPool commandPool) {
assert(commandPool in State.CommandPools)
return State.CommandPools[commandPool]
}
macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) {
assert(surface in State.Surfaces)
return State.Surfaces[surface]
}
macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) {
assert(swapchain in State.Swapchains)
return State.Swapchains[swapchain]
}
macro VkQueueFlags AddQueueFlag(VkQueueFlags flags, VkQueueFlagBits bit) {
return as!VkQueueFlags(as!u32(flags) | as!u32(bit))
}