{ ============================================================================ Copyright (c) 2015-2016 The Khronos Group Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and/or associated documentation files (the "Materials"), to deal in the Materials without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Materials, and to permit persons to whom the Materials are furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Materials. THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. ------------------------------------------------------------------------ This file, vk.xml, is the Vulkan API Registry. It is a critically important and normative part of the Vulkan Specification, including a canonical machine-readable definition of the API, parameter and member validation language incorporated into the Specification and reference pages, and other material which is registered by Khronos, such as tags used by extension and layer authors. The only authoritative version of vk.xml is the one maintained in the master branch of the Khronos Vulkan Github project. ============================================================================== This file is autogenerated from vk.xml You may retrieve the latest version of this file at the Delphi OpenGL Community home page, located at http://www.delphigl.com/ The contents of this file are used with permission, subject to the Mozilla Public License Version 1.1 (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.mozilla.org/MPL/MPL-1.1.html Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. ============================================================================ } unit Vulkan; {$IFDEF FPC} {$MODE Delphi} {$IFNDEF WINDOWS} {$LINKLIB c} {$ENDIF} {$MINENUMSIZE 4} {$ENDIF} {$IFDEF Win32} {$DEFINE VK_WIN} {$ENDIF} {$IFDEF Win64} {$DEFINE VK_WIN} {$ENDIF} {$IFDEF linux} {$DEFINE VK_LINUX} {$DEFINE VK_CDECL} {$ENDIF} {$IFDEF DARWIN} {$DEFINE VK_MAC} {$DEFINE VK_CDECL} {$ENDIF} interface {********************************* VK_VERSION_1_0 *********************************} const { constants } VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; VK_UUID_SIZE = 16; VK_MAX_EXTENSION_NAME_SIZE = 256; VK_MAX_DESCRIPTION_SIZE = 256; VK_MAX_MEMORY_TYPES = 32; VK_MAX_MEMORY_HEAPS = 16; VK_LOD_CLAMP_NONE = 1000; VK_REMAINING_MIP_LEVELS = $FFFFFFFF; VK_REMAINING_ARRAY_LAYERS = $FFFFFFFF; VK_WHOLE_SIZE = $FFFFFFFF; VK_ATTACHMENT_UNUSED = $FFFFFFFF; VK_TRUE = 1; VK_FALSE = 0; VK_QUEUE_FAMILY_IGNORED = $FFFFFFFF; VK_SUBPASS_EXTERNAL = $FFFFFFFF; type { types } PVkVoid = Pointer; VkChar = AnsiChar; VkDouble = Double; VkFloat = Single; VkHandle = Pointer; VkInt16 = SmallInt; VkInt32 = Integer; VkInt64 = Int64; VkSize = SizeUInt; VkUint16 = Word; VkUint32 = Cardinal; VkUint64 = QWord; VkUint8 = Byte; VkBool32 = VkUint32; VkFlags = VkUint32; VkSampleMask = VkUint32; VkDeviceSize = VkUint64; VkAccessFlags = VkFlags; VkAttachmentDescriptionFlags = VkFlags; VkBufferCreateFlags = VkFlags; VkBufferUsageFlags = VkFlags; VkBufferViewCreateFlags = VkFlags; VkColorComponentFlags = VkFlags; VkCommandBufferResetFlags = VkFlags; VkCommandBufferUsageFlags = VkFlags; VkCommandPoolCreateFlags = VkFlags; VkCommandPoolResetFlags = VkFlags; VkCullModeFlags = VkFlags; VkDependencyFlags = VkFlags; VkDescriptorPoolCreateFlags = VkFlags; VkDescriptorPoolResetFlags = VkFlags; VkDescriptorSetLayoutCreateFlags = VkFlags; VkDeviceCreateFlags = VkFlags; VkDeviceQueueCreateFlags = VkFlags; VkEventCreateFlags = VkFlags; VkFenceCreateFlags = VkFlags; VkFormatFeatureFlags = VkFlags; VkFramebufferCreateFlags = VkFlags; VkImageAspectFlags = VkFlags; VkImageCreateFlags = VkFlags; VkImageUsageFlags = VkFlags; VkImageViewCreateFlags = VkFlags; VkInstanceCreateFlags = VkFlags; VkMemoryHeapFlags = VkFlags; VkMemoryMapFlags = VkFlags; VkMemoryPropertyFlags = VkFlags; VkPipelineCacheCreateFlags = VkFlags; VkPipelineColorBlendStateCreateFlags = VkFlags; VkPipelineCreateFlags = VkFlags; VkPipelineDepthStencilStateCreateFlags = VkFlags; VkPipelineDynamicStateCreateFlags = VkFlags; VkPipelineInputAssemblyStateCreateFlags = VkFlags; VkPipelineLayoutCreateFlags = VkFlags; VkPipelineMultisampleStateCreateFlags = VkFlags; VkPipelineRasterizationStateCreateFlags = VkFlags; VkPipelineShaderStageCreateFlags = VkFlags; VkPipelineStageFlags = VkFlags; VkPipelineTessellationStateCreateFlags = VkFlags; VkPipelineVertexInputStateCreateFlags = VkFlags; VkPipelineViewportStateCreateFlags = VkFlags; VkQueryControlFlags = VkFlags; VkQueryPipelineStatisticFlags = VkFlags; VkQueryPoolCreateFlags = VkFlags; VkQueryResultFlags = VkFlags; VkQueueFlags = VkFlags; VkRenderPassCreateFlags = VkFlags; VkSampleCountFlags = VkFlags; VkSamplerCreateFlags = VkFlags; VkSemaphoreCreateFlags = VkFlags; VkShaderModuleCreateFlags = VkFlags; VkShaderStageFlags = VkFlags; VkSparseImageFormatFlags = VkFlags; VkSparseMemoryBindFlags = VkFlags; VkStencilFaceFlags = VkFlags; VkSubpassDescriptionFlags = VkFlags; type { type pointers } PPVkVoid = ^PVkVoid; PPPVkVoid = ^PPVkVoid; PVkChar = ^VkChar; PPVkChar = ^PVkChar; PVkDouble = ^VkDouble; PPVkDouble = ^PVkDouble; PVkFloat = ^VkFloat; PPVkFloat = ^PVkFloat; PVkHandle = ^VkHandle; PPVkHandle = ^PVkHandle; PVkInt16 = ^VkInt16; PPVkInt16 = ^PVkInt16; PVkInt32 = ^VkInt32; PPVkInt32 = ^PVkInt32; PVkInt64 = ^VkInt64; PPVkInt64 = ^PVkInt64; PVkSize = ^VkSize; PPVkSize = ^PVkSize; PVkUint16 = ^VkUint16; PPVkUint16 = ^PVkUint16; PVkUint32 = ^VkUint32; PPVkUint32 = ^PVkUint32; PVkUint64 = ^VkUint64; PPVkUint64 = ^PVkUint64; PVkUint8 = ^VkUint8; PPVkUint8 = ^PVkUint8; PVkBool32 = ^VkBool32; PPVkBool32 = ^PVkBool32; PVkFlags = ^VkFlags; PPVkFlags = ^PVkFlags; PVkSampleMask = ^VkSampleMask; PPVkSampleMask = ^PVkSampleMask; PVkDeviceSize = ^VkDeviceSize; PPVkDeviceSize = ^PVkDeviceSize; PVkAccessFlags = ^VkAccessFlags; PPVkAccessFlags = ^PVkAccessFlags; PVkAttachmentDescriptionFlags = ^VkAttachmentDescriptionFlags; PPVkAttachmentDescriptionFlags = ^PVkAttachmentDescriptionFlags; PVkBufferCreateFlags = ^VkBufferCreateFlags; PPVkBufferCreateFlags = ^PVkBufferCreateFlags; PVkBufferUsageFlags = ^VkBufferUsageFlags; PPVkBufferUsageFlags = ^PVkBufferUsageFlags; PVkBufferViewCreateFlags = ^VkBufferViewCreateFlags; PPVkBufferViewCreateFlags = ^PVkBufferViewCreateFlags; PVkColorComponentFlags = ^VkColorComponentFlags; PPVkColorComponentFlags = ^PVkColorComponentFlags; PVkCommandBufferResetFlags = ^VkCommandBufferResetFlags; PPVkCommandBufferResetFlags = ^PVkCommandBufferResetFlags; PVkCommandBufferUsageFlags = ^VkCommandBufferUsageFlags; PPVkCommandBufferUsageFlags = ^PVkCommandBufferUsageFlags; PVkCommandPoolCreateFlags = ^VkCommandPoolCreateFlags; PPVkCommandPoolCreateFlags = ^PVkCommandPoolCreateFlags; PVkCommandPoolResetFlags = ^VkCommandPoolResetFlags; PPVkCommandPoolResetFlags = ^PVkCommandPoolResetFlags; PVkCullModeFlags = ^VkCullModeFlags; PPVkCullModeFlags = ^PVkCullModeFlags; PVkDependencyFlags = ^VkDependencyFlags; PPVkDependencyFlags = ^PVkDependencyFlags; PVkDescriptorPoolCreateFlags = ^VkDescriptorPoolCreateFlags; PPVkDescriptorPoolCreateFlags = ^PVkDescriptorPoolCreateFlags; PVkDescriptorPoolResetFlags = ^VkDescriptorPoolResetFlags; PPVkDescriptorPoolResetFlags = ^PVkDescriptorPoolResetFlags; PVkDescriptorSetLayoutCreateFlags = ^VkDescriptorSetLayoutCreateFlags; PPVkDescriptorSetLayoutCreateFlags = ^PVkDescriptorSetLayoutCreateFlags; PVkDeviceCreateFlags = ^VkDeviceCreateFlags; PPVkDeviceCreateFlags = ^PVkDeviceCreateFlags; PVkDeviceQueueCreateFlags = ^VkDeviceQueueCreateFlags; PPVkDeviceQueueCreateFlags = ^PVkDeviceQueueCreateFlags; PVkEventCreateFlags = ^VkEventCreateFlags; PPVkEventCreateFlags = ^PVkEventCreateFlags; PVkFenceCreateFlags = ^VkFenceCreateFlags; PPVkFenceCreateFlags = ^PVkFenceCreateFlags; PVkFormatFeatureFlags = ^VkFormatFeatureFlags; PPVkFormatFeatureFlags = ^PVkFormatFeatureFlags; PVkFramebufferCreateFlags = ^VkFramebufferCreateFlags; PPVkFramebufferCreateFlags = ^PVkFramebufferCreateFlags; PVkImageAspectFlags = ^VkImageAspectFlags; PPVkImageAspectFlags = ^PVkImageAspectFlags; PVkImageCreateFlags = ^VkImageCreateFlags; PPVkImageCreateFlags = ^PVkImageCreateFlags; PVkImageUsageFlags = ^VkImageUsageFlags; PPVkImageUsageFlags = ^PVkImageUsageFlags; PVkImageViewCreateFlags = ^VkImageViewCreateFlags; PPVkImageViewCreateFlags = ^PVkImageViewCreateFlags; PVkInstanceCreateFlags = ^VkInstanceCreateFlags; PPVkInstanceCreateFlags = ^PVkInstanceCreateFlags; PVkMemoryHeapFlags = ^VkMemoryHeapFlags; PPVkMemoryHeapFlags = ^PVkMemoryHeapFlags; PVkMemoryMapFlags = ^VkMemoryMapFlags; PPVkMemoryMapFlags = ^PVkMemoryMapFlags; PVkMemoryPropertyFlags = ^VkMemoryPropertyFlags; PPVkMemoryPropertyFlags = ^PVkMemoryPropertyFlags; PVkPipelineCacheCreateFlags = ^VkPipelineCacheCreateFlags; PPVkPipelineCacheCreateFlags = ^PVkPipelineCacheCreateFlags; PVkPipelineColorBlendStateCreateFlags = ^VkPipelineColorBlendStateCreateFlags; PPVkPipelineColorBlendStateCreateFlags = ^PVkPipelineColorBlendStateCreateFlags; PVkPipelineCreateFlags = ^VkPipelineCreateFlags; PPVkPipelineCreateFlags = ^PVkPipelineCreateFlags; PVkPipelineDepthStencilStateCreateFlags = ^VkPipelineDepthStencilStateCreateFlags; PPVkPipelineDepthStencilStateCreateFlags = ^PVkPipelineDepthStencilStateCreateFlags; PVkPipelineDynamicStateCreateFlags = ^VkPipelineDynamicStateCreateFlags; PPVkPipelineDynamicStateCreateFlags = ^PVkPipelineDynamicStateCreateFlags; PVkPipelineInputAssemblyStateCreateFlags = ^VkPipelineInputAssemblyStateCreateFlags; PPVkPipelineInputAssemblyStateCreateFlags = ^PVkPipelineInputAssemblyStateCreateFlags; PVkPipelineLayoutCreateFlags = ^VkPipelineLayoutCreateFlags; PPVkPipelineLayoutCreateFlags = ^PVkPipelineLayoutCreateFlags; PVkPipelineMultisampleStateCreateFlags = ^VkPipelineMultisampleStateCreateFlags; PPVkPipelineMultisampleStateCreateFlags = ^PVkPipelineMultisampleStateCreateFlags; PVkPipelineRasterizationStateCreateFlags = ^VkPipelineRasterizationStateCreateFlags; PPVkPipelineRasterizationStateCreateFlags = ^PVkPipelineRasterizationStateCreateFlags; PVkPipelineShaderStageCreateFlags = ^VkPipelineShaderStageCreateFlags; PPVkPipelineShaderStageCreateFlags = ^PVkPipelineShaderStageCreateFlags; PVkPipelineStageFlags = ^VkPipelineStageFlags; PPVkPipelineStageFlags = ^PVkPipelineStageFlags; PVkPipelineTessellationStateCreateFlags = ^VkPipelineTessellationStateCreateFlags; PPVkPipelineTessellationStateCreateFlags = ^PVkPipelineTessellationStateCreateFlags; PVkPipelineVertexInputStateCreateFlags = ^VkPipelineVertexInputStateCreateFlags; PPVkPipelineVertexInputStateCreateFlags = ^PVkPipelineVertexInputStateCreateFlags; PVkPipelineViewportStateCreateFlags = ^VkPipelineViewportStateCreateFlags; PPVkPipelineViewportStateCreateFlags = ^PVkPipelineViewportStateCreateFlags; PVkQueryControlFlags = ^VkQueryControlFlags; PPVkQueryControlFlags = ^PVkQueryControlFlags; PVkQueryPipelineStatisticFlags = ^VkQueryPipelineStatisticFlags; PPVkQueryPipelineStatisticFlags = ^PVkQueryPipelineStatisticFlags; PVkQueryPoolCreateFlags = ^VkQueryPoolCreateFlags; PPVkQueryPoolCreateFlags = ^PVkQueryPoolCreateFlags; PVkQueryResultFlags = ^VkQueryResultFlags; PPVkQueryResultFlags = ^PVkQueryResultFlags; PVkQueueFlags = ^VkQueueFlags; PPVkQueueFlags = ^PVkQueueFlags; PVkRenderPassCreateFlags = ^VkRenderPassCreateFlags; PPVkRenderPassCreateFlags = ^PVkRenderPassCreateFlags; PVkSampleCountFlags = ^VkSampleCountFlags; PPVkSampleCountFlags = ^PVkSampleCountFlags; PVkSamplerCreateFlags = ^VkSamplerCreateFlags; PPVkSamplerCreateFlags = ^PVkSamplerCreateFlags; PVkSemaphoreCreateFlags = ^VkSemaphoreCreateFlags; PPVkSemaphoreCreateFlags = ^PVkSemaphoreCreateFlags; PVkShaderModuleCreateFlags = ^VkShaderModuleCreateFlags; PPVkShaderModuleCreateFlags = ^PVkShaderModuleCreateFlags; PVkShaderStageFlags = ^VkShaderStageFlags; PPVkShaderStageFlags = ^PVkShaderStageFlags; PVkSparseImageFormatFlags = ^VkSparseImageFormatFlags; PPVkSparseImageFormatFlags = ^PVkSparseImageFormatFlags; PVkSparseMemoryBindFlags = ^VkSparseMemoryBindFlags; PPVkSparseMemoryBindFlags = ^PVkSparseMemoryBindFlags; PVkStencilFaceFlags = ^VkStencilFaceFlags; PPVkStencilFaceFlags = ^PVkStencilFaceFlags; PVkSubpassDescriptionFlags = ^VkSubpassDescriptionFlags; PPVkSubpassDescriptionFlags = ^PVkSubpassDescriptionFlags; type { handles } VkBuffer = VkHandle; VkBufferView = VkHandle; VkCommandBuffer = VkHandle; VkCommandPool = VkHandle; VkDescriptorPool = VkHandle; VkDescriptorSet = VkHandle; VkDescriptorSetLayout = VkHandle; VkDevice = VkHandle; VkDeviceMemory = VkHandle; VkEvent = VkHandle; VkFence = VkHandle; VkFramebuffer = VkHandle; VkImage = VkHandle; VkImageView = VkHandle; VkInstance = VkHandle; VkPhysicalDevice = VkHandle; VkPipeline = VkHandle; VkPipelineCache = VkHandle; VkPipelineLayout = VkHandle; VkQueryPool = VkHandle; VkQueue = VkHandle; VkRenderPass = VkHandle; VkSampler = VkHandle; VkSemaphore = VkHandle; VkShaderModule = VkHandle; type { handle pointers } PVkBuffer = ^VkBuffer; PPVkBuffer = ^PVkBuffer; PVkBufferView = ^VkBufferView; PPVkBufferView = ^PVkBufferView; PVkCommandBuffer = ^VkCommandBuffer; PPVkCommandBuffer = ^PVkCommandBuffer; PVkCommandPool = ^VkCommandPool; PPVkCommandPool = ^PVkCommandPool; PVkDescriptorPool = ^VkDescriptorPool; PPVkDescriptorPool = ^PVkDescriptorPool; PVkDescriptorSet = ^VkDescriptorSet; PPVkDescriptorSet = ^PVkDescriptorSet; PVkDescriptorSetLayout = ^VkDescriptorSetLayout; PPVkDescriptorSetLayout = ^PVkDescriptorSetLayout; PVkDevice = ^VkDevice; PPVkDevice = ^PVkDevice; PVkDeviceMemory = ^VkDeviceMemory; PPVkDeviceMemory = ^PVkDeviceMemory; PVkEvent = ^VkEvent; PPVkEvent = ^PVkEvent; PVkFence = ^VkFence; PPVkFence = ^PVkFence; PVkFramebuffer = ^VkFramebuffer; PPVkFramebuffer = ^PVkFramebuffer; PVkImage = ^VkImage; PPVkImage = ^PVkImage; PVkImageView = ^VkImageView; PPVkImageView = ^PVkImageView; PVkInstance = ^VkInstance; PPVkInstance = ^PVkInstance; PVkPhysicalDevice = ^VkPhysicalDevice; PPVkPhysicalDevice = ^PVkPhysicalDevice; PVkPipeline = ^VkPipeline; PPVkPipeline = ^PVkPipeline; PVkPipelineCache = ^VkPipelineCache; PPVkPipelineCache = ^PVkPipelineCache; PVkPipelineLayout = ^VkPipelineLayout; PPVkPipelineLayout = ^PVkPipelineLayout; PVkQueryPool = ^VkQueryPool; PPVkQueryPool = ^PVkQueryPool; PVkQueue = ^VkQueue; PPVkQueue = ^PVkQueue; PVkRenderPass = ^VkRenderPass; PPVkRenderPass = ^PVkRenderPass; PVkSampler = ^VkSampler; PPVkSampler = ^PVkSampler; PVkSemaphore = ^VkSemaphore; PPVkSemaphore = ^PVkSemaphore; PVkShaderModule = ^VkShaderModule; PPVkShaderModule = ^PVkShaderModule; type { enums } TVkAttachmentLoadOp = ( VK_ATTACHMENT_LOAD_OP_LOAD = 0, VK_ATTACHMENT_LOAD_OP_CLEAR = 1, VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2 ); PVkAttachmentLoadOp = ^TVkAttachmentLoadOp; TVkAttachmentStoreOp = ( VK_ATTACHMENT_STORE_OP_STORE = 0, VK_ATTACHMENT_STORE_OP_DONT_CARE = 1 ); PVkAttachmentStoreOp = ^TVkAttachmentStoreOp; TVkBlendFactor = ( VK_BLEND_FACTOR_ZERO = 0, VK_BLEND_FACTOR_ONE = 1, VK_BLEND_FACTOR_SRC_COLOR = 2, VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, VK_BLEND_FACTOR_DST_COLOR = 4, VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, VK_BLEND_FACTOR_SRC_ALPHA = 6, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, VK_BLEND_FACTOR_DST_ALPHA = 8, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, VK_BLEND_FACTOR_CONSTANT_COLOR = 10, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, VK_BLEND_FACTOR_SRC1_COLOR = 15, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, VK_BLEND_FACTOR_SRC1_ALPHA = 17, VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18 ); PVkBlendFactor = ^TVkBlendFactor; TVkBlendOp = ( VK_BLEND_OP_ADD = 0, VK_BLEND_OP_SUBTRACT = 1, VK_BLEND_OP_REVERSE_SUBTRACT = 2, VK_BLEND_OP_MIN = 3, VK_BLEND_OP_MAX = 4 ); PVkBlendOp = ^TVkBlendOp; TVkBorderColor = ( VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5 ); PVkBorderColor = ^TVkBorderColor; TVkCommandBufferLevel = ( VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1 ); PVkCommandBufferLevel = ^TVkCommandBufferLevel; TVkCompareOp = ( VK_COMPARE_OP_NEVER = 0, VK_COMPARE_OP_LESS = 1, VK_COMPARE_OP_EQUAL = 2, VK_COMPARE_OP_LESS_OR_EQUAL = 3, VK_COMPARE_OP_GREATER = 4, VK_COMPARE_OP_NOT_EQUAL = 5, VK_COMPARE_OP_GREATER_OR_EQUAL = 6, VK_COMPARE_OP_ALWAYS = 7 ); PVkCompareOp = ^TVkCompareOp; TVkComponentSwizzle = ( VK_COMPONENT_SWIZZLE_IDENTITY = 0, VK_COMPONENT_SWIZZLE_ZERO = 1, VK_COMPONENT_SWIZZLE_ONE = 2, VK_COMPONENT_SWIZZLE_R = 3, VK_COMPONENT_SWIZZLE_G = 4, VK_COMPONENT_SWIZZLE_B = 5, VK_COMPONENT_SWIZZLE_A = 6 ); PVkComponentSwizzle = ^TVkComponentSwizzle; TVkDescriptorType = ( VK_DESCRIPTOR_TYPE_SAMPLER = 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10 ); PVkDescriptorType = ^TVkDescriptorType; TVkDynamicState = ( VK_DYNAMIC_STATE_VIEWPORT = 0, VK_DYNAMIC_STATE_SCISSOR = 1, VK_DYNAMIC_STATE_LINE_WIDTH = 2, VK_DYNAMIC_STATE_DEPTH_BIAS = 3, VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8 ); PVkDynamicState = ^TVkDynamicState; TVkFilter = ( VK_FILTER_NEAREST = 0, VK_FILTER_LINEAR = 1 ); PVkFilter = ^TVkFilter; TVkFormat = ( 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 ); PVkFormat = ^TVkFormat; TVkFrontFace = ( VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, VK_FRONT_FACE_CLOCKWISE = 1 ); PVkFrontFace = ^TVkFrontFace; TVkImageLayout = ( VK_IMAGE_LAYOUT_UNDEFINED = 0, VK_IMAGE_LAYOUT_GENERAL = 1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, VK_IMAGE_LAYOUT_PREINITIALIZED = 8 ); PVkImageLayout = ^TVkImageLayout; TVkImageTiling = ( VK_IMAGE_TILING_OPTIMAL = 0, VK_IMAGE_TILING_LINEAR = 1 ); PVkImageTiling = ^TVkImageTiling; TVkImageType = ( VK_IMAGE_TYPE_1D = 0, VK_IMAGE_TYPE_2D = 1, VK_IMAGE_TYPE_3D = 2 ); PVkImageType = ^TVkImageType; TVkImageViewType = ( VK_IMAGE_VIEW_TYPE_1D = 0, VK_IMAGE_VIEW_TYPE_2D = 1, VK_IMAGE_VIEW_TYPE_3D = 2, VK_IMAGE_VIEW_TYPE_CUBE = 3, VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6 ); PVkImageViewType = ^TVkImageViewType; TVkIndexType = ( VK_INDEX_TYPE_UINT16 = 0, VK_INDEX_TYPE_UINT32 = 1 ); PVkIndexType = ^TVkIndexType; TVkInternalAllocationType = ( VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0 ); PVkInternalAllocationType = ^TVkInternalAllocationType; TVkLogicOp = ( VK_LOGIC_OP_CLEAR = 0, VK_LOGIC_OP_AND = 1, VK_LOGIC_OP_AND_REVERSE = 2, VK_LOGIC_OP_COPY = 3, VK_LOGIC_OP_AND_INVERTED = 4, VK_LOGIC_OP_NO_OP = 5, VK_LOGIC_OP_XOR = 6, VK_LOGIC_OP_OR = 7, VK_LOGIC_OP_NOR = 8, VK_LOGIC_OP_EQUIVALENT = 9, VK_LOGIC_OP_INVERT = 10, VK_LOGIC_OP_OR_REVERSE = 11, VK_LOGIC_OP_COPY_INVERTED = 12, VK_LOGIC_OP_OR_INVERTED = 13, VK_LOGIC_OP_NAND = 14, VK_LOGIC_OP_SET = 15 ); PVkLogicOp = ^TVkLogicOp; TVkPhysicalDeviceType = ( VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, VK_PHYSICAL_DEVICE_TYPE_CPU = 4 ); PVkPhysicalDeviceType = ^TVkPhysicalDeviceType; TVkPipelineBindPoint = ( VK_PIPELINE_BIND_POINT_GRAPHICS = 0, VK_PIPELINE_BIND_POINT_COMPUTE = 1 ); PVkPipelineBindPoint = ^TVkPipelineBindPoint; TVkPipelineCacheHeaderVersion = ( VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1 ); PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion; TVkPipelineStageFlagBits = ( VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = (1 shl 0), VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = (1 shl 1), VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = (1 shl 2), VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = (1 shl 3), VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = (1 shl 4), VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = (1 shl 5), VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = (1 shl 6), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = (1 shl 7), VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = (1 shl 8), VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = (1 shl 9), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = (1 shl 10), VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = (1 shl 11), VK_PIPELINE_STAGE_TRANSFER_BIT = (1 shl 12), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = (1 shl 13), VK_PIPELINE_STAGE_HOST_BIT = (1 shl 14), VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = (1 shl 15), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = (1 shl 16) ); PVkPipelineStageFlagBits = ^TVkPipelineStageFlagBits; TVkPolygonMode = ( VK_POLYGON_MODE_FILL = 0, VK_POLYGON_MODE_LINE = 1, VK_POLYGON_MODE_POINT = 2 ); PVkPolygonMode = ^TVkPolygonMode; TVkPrimitiveTopology = ( VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10 ); PVkPrimitiveTopology = ^TVkPrimitiveTopology; TVkQueryType = ( VK_QUERY_TYPE_OCCLUSION = 0, VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, VK_QUERY_TYPE_TIMESTAMP = 2 ); PVkQueryType = ^TVkQueryType; TVkResult = ( VK_SUCCESS = 0, VK_NOT_READY = 1, VK_TIMEOUT = 2, VK_EVENT_SET = 3, VK_EVENT_RESET = 4, VK_INCOMPLETE = 5, VK_ERROR_OUT_OF_HOST_MEMORY = -1, VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, VK_ERROR_INITIALIZATION_FAILED = -3, VK_ERROR_DEVICE_LOST = -4, VK_ERROR_MEMORY_MAP_FAILED = -5, VK_ERROR_LAYER_NOT_PRESENT = -6, VK_ERROR_EXTENSION_NOT_PRESENT = -7, VK_ERROR_FEATURE_NOT_PRESENT = -8, VK_ERROR_INCOMPATIBLE_DRIVER = -9, VK_ERROR_TOO_MANY_OBJECTS = -10, VK_ERROR_FORMAT_NOT_SUPPORTED = -11 ); PVkResult = ^TVkResult; TVkSampleCountFlagBits = ( VK_SAMPLE_COUNT_1_BIT = (1 shl 0), VK_SAMPLE_COUNT_2_BIT = (1 shl 1), VK_SAMPLE_COUNT_4_BIT = (1 shl 2), VK_SAMPLE_COUNT_8_BIT = (1 shl 3), VK_SAMPLE_COUNT_16_BIT = (1 shl 4), VK_SAMPLE_COUNT_32_BIT = (1 shl 5), VK_SAMPLE_COUNT_64_BIT = (1 shl 6) ); PVkSampleCountFlagBits = ^TVkSampleCountFlagBits; TVkSamplerAddressMode = ( VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4 ); PVkSamplerAddressMode = ^TVkSamplerAddressMode; TVkSamplerMipmapMode = ( VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, VK_SAMPLER_MIPMAP_MODE_LINEAR = 1 ); PVkSamplerMipmapMode = ^TVkSamplerMipmapMode; TVkShaderStageFlagBits = ( VK_SHADER_STAGE_VERTEX_BIT = (1 shl 0), VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = (1 shl 1), VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = (1 shl 2), VK_SHADER_STAGE_GEOMETRY_BIT = (1 shl 3), VK_SHADER_STAGE_FRAGMENT_BIT = (1 shl 4), VK_SHADER_STAGE_COMPUTE_BIT = (1 shl 5), VK_SHADER_STAGE_ALL_GRAPHICS = $1F, VK_SHADER_STAGE_ALL = $7FFFFFFF ); PVkShaderStageFlagBits = ^TVkShaderStageFlagBits; TVkSharingMode = ( VK_SHARING_MODE_EXCLUSIVE = 0, VK_SHARING_MODE_CONCURRENT = 1 ); PVkSharingMode = ^TVkSharingMode; TVkStencilOp = ( VK_STENCIL_OP_KEEP = 0, VK_STENCIL_OP_ZERO = 1, VK_STENCIL_OP_REPLACE = 2, VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, VK_STENCIL_OP_INVERT = 5, VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, VK_STENCIL_OP_DECREMENT_AND_WRAP = 7 ); PVkStencilOp = ^TVkStencilOp; TVkStructureType = ( 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 ); PVkStructureType = ^TVkStructureType; TVkSubpassContents = ( VK_SUBPASS_CONTENTS_INLINE = 0, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1 ); PVkSubpassContents = ^TVkSubpassContents; TVkSystemAllocationScope = ( VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4 ); PVkSystemAllocationScope = ^TVkSystemAllocationScope; TVkVertexInputRate = ( VK_VERTEX_INPUT_RATE_VERTEX = 0, VK_VERTEX_INPUT_RATE_INSTANCE = 1 ); PVkVertexInputRate = ^TVkVertexInputRate; type { funcptrs } TvkVoidFunction = procedure(); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkFreeFunction = procedure(pUserData: PVkVoid; pMemory: PVkVoid); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkAllocationFunction = procedure(pUserData: PVkVoid; size: VkSize; alignment: VkSize; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkInternalAllocationNotification = procedure(pUserData: PVkVoid; size: VkSize; allocationType: TVkInternalAllocationType; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkInternalFreeNotification = procedure(pUserData: PVkVoid; size: VkSize; allocationType: TVkInternalAllocationType; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkReallocationFunction = procedure(pUserData: PVkVoid; pOriginal: PVkVoid; size: VkSize; alignment: VkSize; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; type { structs } TVkViewport = record x: VkFloat; y: VkFloat; width: VkFloat; height: VkFloat; minDepth: VkFloat; maxDepth: VkFloat; end; PVkViewport = ^TVkViewport; PPVkViewport = ^PVkViewport; TVkOffset2D = record x: VkInt32; y: VkInt32; end; PVkOffset2D = ^TVkOffset2D; PPVkOffset2D = ^PVkOffset2D; TVkOffset3D = record x: VkInt32; y: VkInt32; z: VkInt32; end; PVkOffset3D = ^TVkOffset3D; PPVkOffset3D = ^PVkOffset3D; TVkClearColorValue = record case Integer of 000: (float32: array[0..4] of VkFloat); 001: (int32: array[0..4] of VkInt32); 002: (uint32: array[0..4] of VkUint32); end; PVkClearColorValue = ^TVkClearColorValue; PPVkClearColorValue = ^PVkClearColorValue; TVkClearDepthStencilValue = record depth: VkFloat; stencil: VkUint32; end; PVkClearDepthStencilValue = ^TVkClearDepthStencilValue; PPVkClearDepthStencilValue = ^PVkClearDepthStencilValue; TVkDispatchIndirectCommand = record x: VkUint32; y: VkUint32; z: VkUint32; end; PVkDispatchIndirectCommand = ^TVkDispatchIndirectCommand; PPVkDispatchIndirectCommand = ^PVkDispatchIndirectCommand; TVkDrawIndexedIndirectCommand = record indexCount: VkUint32; instanceCount: VkUint32; firstIndex: VkUint32; vertexOffset: VkInt32; firstInstance: VkUint32; end; PVkDrawIndexedIndirectCommand = ^TVkDrawIndexedIndirectCommand; PPVkDrawIndexedIndirectCommand = ^PVkDrawIndexedIndirectCommand; TVkDrawIndirectCommand = record vertexCount: VkUint32; instanceCount: VkUint32; firstVertex: VkUint32; firstInstance: VkUint32; end; PVkDrawIndirectCommand = ^TVkDrawIndirectCommand; PPVkDrawIndirectCommand = ^PVkDrawIndirectCommand; TVkExtensionProperties = record extensionName: array[0..VK_MAX_EXTENSION_NAME_SIZE-1] of VkChar; specVersion: VkUint32; end; PVkExtensionProperties = ^TVkExtensionProperties; PPVkExtensionProperties = ^PVkExtensionProperties; TVkExtent2D = record width: VkUint32; height: VkUint32; end; PVkExtent2D = ^TVkExtent2D; PPVkExtent2D = ^PVkExtent2D; TVkExtent3D = record width: VkUint32; height: VkUint32; depth: VkUint32; end; PVkExtent3D = ^TVkExtent3D; PPVkExtent3D = ^PVkExtent3D; TVkLayerProperties = record layerName: array[0..VK_MAX_EXTENSION_NAME_SIZE-1] of VkChar; specVersion: VkUint32; implementationVersion: VkUint32; description: array[0..VK_MAX_DESCRIPTION_SIZE-1] of VkChar; end; PVkLayerProperties = ^TVkLayerProperties; PPVkLayerProperties = ^PVkLayerProperties; TVkSpecializationMapEntry = record constantID: VkUint32; offset: VkUint32; size: VkSize; end; PVkSpecializationMapEntry = ^TVkSpecializationMapEntry; PPVkSpecializationMapEntry = ^PVkSpecializationMapEntry; TVkPhysicalDeviceFeatures = record robustBufferAccess: VkBool32; fullDrawIndexUint32: VkBool32; imageCubeArray: VkBool32; independentBlend: VkBool32; geometryShader: VkBool32; tessellationShader: VkBool32; sampleRateShading: VkBool32; dualSrcBlend: VkBool32; logicOp: VkBool32; multiDrawIndirect: VkBool32; drawIndirectFirstInstance: VkBool32; depthClamp: VkBool32; depthBiasClamp: VkBool32; fillModeNonSolid: VkBool32; depthBounds: VkBool32; wideLines: VkBool32; largePoints: VkBool32; alphaToOne: VkBool32; multiViewport: VkBool32; samplerAnisotropy: VkBool32; textureCompressionETC2: VkBool32; textureCompressionASTC_LDR: VkBool32; textureCompressionBC: VkBool32; occlusionQueryPrecise: VkBool32; pipelineStatisticsQuery: VkBool32; vertexPipelineStoresAndAtomics: VkBool32; fragmentStoresAndAtomics: VkBool32; shaderTessellationAndGeometryPointSize: VkBool32; shaderImageGatherExtended: VkBool32; shaderStorageImageExtendedFormats: VkBool32; shaderStorageImageMultisample: VkBool32; shaderStorageImageReadWithoutFormat: VkBool32; shaderStorageImageWriteWithoutFormat: VkBool32; shaderUniformBufferArrayDynamicIndexing: VkBool32; shaderSampledImageArrayDynamicIndexing: VkBool32; shaderStorageBufferArrayDynamicIndexing: VkBool32; shaderStorageImageArrayDynamicIndexing: VkBool32; shaderClipDistance: VkBool32; shaderCullDistance: VkBool32; shaderFloat64: VkBool32; shaderInt64: VkBool32; shaderInt16: VkBool32; shaderResourceResidency: VkBool32; shaderResourceMinLod: VkBool32; sparseBinding: VkBool32; sparseResidencyBuffer: VkBool32; sparseResidencyImage2D: VkBool32; sparseResidencyImage3D: VkBool32; sparseResidency2Samples: VkBool32; sparseResidency4Samples: VkBool32; sparseResidency8Samples: VkBool32; sparseResidency16Samples: VkBool32; sparseResidencyAliased: VkBool32; variableMultisampleRate: VkBool32; inheritedQueries: VkBool32; end; PVkPhysicalDeviceFeatures = ^TVkPhysicalDeviceFeatures; PPVkPhysicalDeviceFeatures = ^PVkPhysicalDeviceFeatures; TVkPhysicalDeviceSparseProperties = record residencyStandard2DBlockShape: VkBool32; residencyStandard2DMultisampleBlockShape: VkBool32; residencyStandard3DBlockShape: VkBool32; residencyAlignedMipSize: VkBool32; residencyNonResidentStrict: VkBool32; end; PVkPhysicalDeviceSparseProperties = ^TVkPhysicalDeviceSparseProperties; PPVkPhysicalDeviceSparseProperties = ^PVkPhysicalDeviceSparseProperties; TVkBufferCopy = record srcOffset: VkDeviceSize; dstOffset: VkDeviceSize; size: VkDeviceSize; end; PVkBufferCopy = ^TVkBufferCopy; PPVkBufferCopy = ^PVkBufferCopy; TVkMemoryRequirements = record size: VkDeviceSize; alignment: VkDeviceSize; memoryTypeBits: VkUint32; end; PVkMemoryRequirements = ^TVkMemoryRequirements; PPVkMemoryRequirements = ^PVkMemoryRequirements; TVkSubresourceLayout = record offset: VkDeviceSize; size: VkDeviceSize; rowPitch: VkDeviceSize; arrayPitch: VkDeviceSize; depthPitch: VkDeviceSize; end; PVkSubresourceLayout = ^TVkSubresourceLayout; PPVkSubresourceLayout = ^PVkSubresourceLayout; TVkFormatProperties = record linearTilingFeatures: VkFormatFeatureFlags; optimalTilingFeatures: VkFormatFeatureFlags; bufferFeatures: VkFormatFeatureFlags; end; PVkFormatProperties = ^TVkFormatProperties; PPVkFormatProperties = ^PVkFormatProperties; TVkImageSubresource = record aspectMask: VkImageAspectFlags; mipLevel: VkUint32; arrayLayer: VkUint32; end; PVkImageSubresource = ^TVkImageSubresource; PPVkImageSubresource = ^PVkImageSubresource; TVkImageSubresourceLayers = record aspectMask: VkImageAspectFlags; mipLevel: VkUint32; baseArrayLayer: VkUint32; layerCount: VkUint32; end; PVkImageSubresourceLayers = ^TVkImageSubresourceLayers; PPVkImageSubresourceLayers = ^PVkImageSubresourceLayers; TVkImageSubresourceRange = record aspectMask: VkImageAspectFlags; baseMipLevel: VkUint32; levelCount: VkUint32; baseArrayLayer: VkUint32; layerCount: VkUint32; end; PVkImageSubresourceRange = ^TVkImageSubresourceRange; PPVkImageSubresourceRange = ^PVkImageSubresourceRange; TVkMemoryHeap = record size: VkDeviceSize; flags: VkMemoryHeapFlags; end; PVkMemoryHeap = ^TVkMemoryHeap; PPVkMemoryHeap = ^PVkMemoryHeap; TVkMemoryType = record propertyFlags: VkMemoryPropertyFlags; heapIndex: VkUint32; end; PVkMemoryType = ^TVkMemoryType; PPVkMemoryType = ^PVkMemoryType; TVkSubpassDependency = record srcSubpass: VkUint32; dstSubpass: VkUint32; srcStageMask: VkPipelineStageFlags; dstStageMask: VkPipelineStageFlags; srcAccessMask: VkAccessFlags; dstAccessMask: VkAccessFlags; dependencyFlags: VkDependencyFlags; end; PVkSubpassDependency = ^TVkSubpassDependency; PPVkSubpassDependency = ^PVkSubpassDependency; TVkPushConstantRange = record stageFlags: VkShaderStageFlags; offset: VkUint32; size: VkUint32; end; PVkPushConstantRange = ^TVkPushConstantRange; PPVkPushConstantRange = ^PVkPushConstantRange; TVkPhysicalDeviceLimits = record maxImageDimension1D: VkUint32; maxImageDimension2D: VkUint32; maxImageDimension3D: VkUint32; maxImageDimensionCube: VkUint32; maxImageArrayLayers: VkUint32; maxTexelBufferElements: VkUint32; maxUniformBufferRange: VkUint32; maxStorageBufferRange: VkUint32; maxPushConstantsSize: VkUint32; maxMemoryAllocationCount: VkUint32; maxSamplerAllocationCount: VkUint32; bufferImageGranularity: VkDeviceSize; sparseAddressSpaceSize: VkDeviceSize; maxBoundDescriptorSets: VkUint32; maxPerStageDescriptorSamplers: VkUint32; maxPerStageDescriptorUniformBuffers: VkUint32; maxPerStageDescriptorStorageBuffers: VkUint32; maxPerStageDescriptorSampledImages: VkUint32; maxPerStageDescriptorStorageImages: VkUint32; maxPerStageDescriptorInputAttachments: VkUint32; maxPerStageResources: VkUint32; maxDescriptorSetSamplers: VkUint32; maxDescriptorSetUniformBuffers: VkUint32; maxDescriptorSetUniformBuffersDynamic: VkUint32; maxDescriptorSetStorageBuffers: VkUint32; maxDescriptorSetStorageBuffersDynamic: VkUint32; maxDescriptorSetSampledImages: VkUint32; maxDescriptorSetStorageImages: VkUint32; maxDescriptorSetInputAttachments: VkUint32; maxVertexInputAttributes: VkUint32; maxVertexInputBindings: VkUint32; maxVertexInputAttributeOffset: VkUint32; maxVertexInputBindingStride: VkUint32; maxVertexOutputComponents: VkUint32; maxTessellationGenerationLevel: VkUint32; maxTessellationPatchSize: VkUint32; maxTessellationControlPerVertexInputComponents: VkUint32; maxTessellationControlPerVertexOutputComponents: VkUint32; maxTessellationControlPerPatchOutputComponents: VkUint32; maxTessellationControlTotalOutputComponents: VkUint32; maxTessellationEvaluationInputComponents: VkUint32; maxTessellationEvaluationOutputComponents: VkUint32; maxGeometryShaderInvocations: VkUint32; maxGeometryInputComponents: VkUint32; maxGeometryOutputComponents: VkUint32; maxGeometryOutputVertices: VkUint32; maxGeometryTotalOutputComponents: VkUint32; maxFragmentInputComponents: VkUint32; maxFragmentOutputAttachments: VkUint32; maxFragmentDualSrcAttachments: VkUint32; maxFragmentCombinedOutputResources: VkUint32; maxComputeSharedMemorySize: VkUint32; maxComputeWorkGroupCount: array[0..3] of VkUint32; maxComputeWorkGroupInvocations: VkUint32; maxComputeWorkGroupSize: array[0..3] of VkUint32; subPixelPrecisionBits: VkUint32; subTexelPrecisionBits: VkUint32; mipmapPrecisionBits: VkUint32; maxDrawIndexedIndexValue: VkUint32; maxDrawIndirectCount: VkUint32; maxSamplerLodBias: VkFloat; maxSamplerAnisotropy: VkFloat; maxViewports: VkUint32; maxViewportDimensions: array[0..2] of VkUint32; viewportBoundsRange: array[0..2] of VkFloat; viewportSubPixelBits: VkUint32; minMemoryMapAlignment: VkSize; minTexelBufferOffsetAlignment: VkDeviceSize; minUniformBufferOffsetAlignment: VkDeviceSize; minStorageBufferOffsetAlignment: VkDeviceSize; minTexelOffset: VkInt32; maxTexelOffset: VkUint32; minTexelGatherOffset: VkInt32; maxTexelGatherOffset: VkUint32; minInterpolationOffset: VkFloat; maxInterpolationOffset: VkFloat; subPixelInterpolationOffsetBits: VkUint32; maxFramebufferWidth: VkUint32; maxFramebufferHeight: VkUint32; maxFramebufferLayers: VkUint32; framebufferColorSampleCounts: VkSampleCountFlags; framebufferDepthSampleCounts: VkSampleCountFlags; framebufferStencilSampleCounts: VkSampleCountFlags; framebufferNoAttachmentsSampleCounts: VkSampleCountFlags; maxColorAttachments: VkUint32; sampledImageColorSampleCounts: VkSampleCountFlags; sampledImageIntegerSampleCounts: VkSampleCountFlags; sampledImageDepthSampleCounts: VkSampleCountFlags; sampledImageStencilSampleCounts: VkSampleCountFlags; storageImageSampleCounts: VkSampleCountFlags; maxSampleMaskWords: VkUint32; timestampComputeAndGraphics: VkBool32; timestampPeriod: VkFloat; maxClipDistances: VkUint32; maxCullDistances: VkUint32; maxCombinedClipAndCullDistances: VkUint32; discreteQueuePriorities: VkUint32; pointSizeRange: array[0..2] of VkFloat; lineWidthRange: array[0..2] of VkFloat; pointSizeGranularity: VkFloat; lineWidthGranularity: VkFloat; strictLines: VkBool32; standardSampleLocations: VkBool32; optimalBufferCopyOffsetAlignment: VkDeviceSize; optimalBufferCopyRowPitchAlignment: VkDeviceSize; nonCoherentAtomSize: VkDeviceSize; end; PVkPhysicalDeviceLimits = ^TVkPhysicalDeviceLimits; PPVkPhysicalDeviceLimits = ^PVkPhysicalDeviceLimits; TVkDescriptorBufferInfo = record buffer: VkBuffer; offset: VkDeviceSize; range: VkDeviceSize; end; PVkDescriptorBufferInfo = ^TVkDescriptorBufferInfo; PPVkDescriptorBufferInfo = ^PVkDescriptorBufferInfo; TVkSparseMemoryBind = record resourceOffset: VkDeviceSize; size: VkDeviceSize; memory: VkDeviceMemory; memoryOffset: VkDeviceSize; flags: VkSparseMemoryBindFlags; end; PVkSparseMemoryBind = ^TVkSparseMemoryBind; PPVkSparseMemoryBind = ^PVkSparseMemoryBind; TVkComponentMapping = record r: TVkComponentSwizzle; g: TVkComponentSwizzle; b: TVkComponentSwizzle; a: TVkComponentSwizzle; end; PVkComponentMapping = ^TVkComponentMapping; PPVkComponentMapping = ^PVkComponentMapping; TVkAttachmentReference = record attachment: VkUint32; layout: TVkImageLayout; end; PVkAttachmentReference = ^TVkAttachmentReference; PPVkAttachmentReference = ^PVkAttachmentReference; TVkDescriptorPoolSize = record dType: TVkDescriptorType; descriptorCount: VkUint32; end; PVkDescriptorPoolSize = ^TVkDescriptorPoolSize; PPVkDescriptorPoolSize = ^PVkDescriptorPoolSize; TVkStencilOpState = record failOp: TVkStencilOp; passOp: TVkStencilOp; depthFailOp: TVkStencilOp; compareOp: TVkCompareOp; compareMask: VkUint32; writeMask: VkUint32; reference: VkUint32; end; PVkStencilOpState = ^TVkStencilOpState; PPVkStencilOpState = ^PVkStencilOpState; TVkVertexInputAttributeDescription = record location: VkUint32; binding: VkUint32; format: TVkFormat; offset: VkUint32; end; PVkVertexInputAttributeDescription = ^TVkVertexInputAttributeDescription; PPVkVertexInputAttributeDescription = ^PVkVertexInputAttributeDescription; TVkVertexInputBindingDescription = record binding: VkUint32; stride: VkUint32; inputRate: TVkVertexInputRate; end; PVkVertexInputBindingDescription = ^TVkVertexInputBindingDescription; PPVkVertexInputBindingDescription = ^PVkVertexInputBindingDescription; TVkApplicationInfo = record sType: TVkStructureType; pNext: PVkVoid; pApplicationName: PVkChar; applicationVersion: VkUint32; pEngineName: PVkChar; engineVersion: VkUint32; apiVersion: VkUint32; end; PVkApplicationInfo = ^TVkApplicationInfo; PPVkApplicationInfo = ^PVkApplicationInfo; TVkCommandBufferAllocateInfo = record sType: TVkStructureType; pNext: PVkVoid; commandPool: VkCommandPool; level: TVkCommandBufferLevel; commandBufferCount: VkUint32; end; PVkCommandBufferAllocateInfo = ^TVkCommandBufferAllocateInfo; PPVkCommandBufferAllocateInfo = ^PVkCommandBufferAllocateInfo; TVkCopyDescriptorSet = record sType: TVkStructureType; pNext: PVkVoid; srcSet: VkDescriptorSet; srcBinding: VkUint32; srcArrayElement: VkUint32; dstSet: VkDescriptorSet; dstBinding: VkUint32; dstArrayElement: VkUint32; descriptorCount: VkUint32; end; PVkCopyDescriptorSet = ^TVkCopyDescriptorSet; PPVkCopyDescriptorSet = ^PVkCopyDescriptorSet; TVkDescriptorSetAllocateInfo = record sType: TVkStructureType; pNext: PVkVoid; descriptorPool: VkDescriptorPool; descriptorSetCount: VkUint32; pSetLayouts: PVkDescriptorSetLayout; end; PVkDescriptorSetAllocateInfo = ^TVkDescriptorSetAllocateInfo; PPVkDescriptorSetAllocateInfo = ^PVkDescriptorSetAllocateInfo; TVkDescriptorImageInfo = record sampler: VkSampler; imageView: VkImageView; imageLayout: TVkImageLayout; end; PVkDescriptorImageInfo = ^TVkDescriptorImageInfo; PPVkDescriptorImageInfo = ^PVkDescriptorImageInfo; TVkClearValue = record case Integer of 000: (color: TVkClearColorValue); 001: (depthStencil: TVkClearDepthStencilValue); end; PVkClearValue = ^TVkClearValue; PPVkClearValue = ^PVkClearValue; TVkRect2D = record offset: TVkOffset2D; extent: TVkExtent2D; end; PVkRect2D = ^TVkRect2D; PPVkRect2D = ^PVkRect2D; TVkSpecializationInfo = record mapEntryCount: VkUint32; pMapEntries: PVkSpecializationMapEntry; dataSize: VkSize; pData: PVkVoid; end; PVkSpecializationInfo = ^TVkSpecializationInfo; PPVkSpecializationInfo = ^PVkSpecializationInfo; TVkBufferMemoryBarrier = record sType: TVkStructureType; pNext: PVkVoid; srcAccessMask: VkAccessFlags; dstAccessMask: VkAccessFlags; srcQueueFamilyIndex: VkUint32; dstQueueFamilyIndex: VkUint32; buffer: VkBuffer; offset: VkDeviceSize; size: VkDeviceSize; end; PVkBufferMemoryBarrier = ^TVkBufferMemoryBarrier; PPVkBufferMemoryBarrier = ^PVkBufferMemoryBarrier; TVkBufferCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkBufferCreateFlags; size: VkDeviceSize; usage: VkBufferUsageFlags; sharingMode: TVkSharingMode; queueFamilyIndexCount: VkUint32; pQueueFamilyIndices: PVkUint32; end; PVkBufferCreateInfo = ^TVkBufferCreateInfo; PPVkBufferCreateInfo = ^PVkBufferCreateInfo; TVkBufferViewCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkBufferViewCreateFlags; buffer: VkBuffer; format: TVkFormat; offset: VkDeviceSize; range: VkDeviceSize; end; PVkBufferViewCreateInfo = ^TVkBufferViewCreateInfo; PPVkBufferViewCreateInfo = ^PVkBufferViewCreateInfo; TVkPipelineColorBlendAttachmentState = record blendEnable: VkBool32; srcColorBlendFactor: TVkBlendFactor; dstColorBlendFactor: TVkBlendFactor; colorBlendOp: TVkBlendOp; srcAlphaBlendFactor: TVkBlendFactor; dstAlphaBlendFactor: TVkBlendFactor; alphaBlendOp: TVkBlendOp; colorWriteMask: VkColorComponentFlags; end; PVkPipelineColorBlendAttachmentState = ^TVkPipelineColorBlendAttachmentState; PPVkPipelineColorBlendAttachmentState = ^PVkPipelineColorBlendAttachmentState; TVkCommandPoolCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkCommandPoolCreateFlags; queueFamilyIndex: VkUint32; end; PVkCommandPoolCreateInfo = ^TVkCommandPoolCreateInfo; PPVkCommandPoolCreateInfo = ^PVkCommandPoolCreateInfo; TVkDeviceQueueCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkDeviceQueueCreateFlags; queueFamilyIndex: VkUint32; queueCount: VkUint32; pQueuePriorities: PVkFloat; end; PVkDeviceQueueCreateInfo = ^TVkDeviceQueueCreateInfo; PPVkDeviceQueueCreateInfo = ^PVkDeviceQueueCreateInfo; TVkCommandBufferInheritanceInfo = record sType: TVkStructureType; pNext: PVkVoid; renderPass: VkRenderPass; subpass: VkUint32; framebuffer: VkFramebuffer; occlusionQueryEnable: VkBool32; queryFlags: VkQueryControlFlags; pipelineStatistics: VkQueryPipelineStatisticFlags; end; PVkCommandBufferInheritanceInfo = ^TVkCommandBufferInheritanceInfo; PPVkCommandBufferInheritanceInfo = ^PVkCommandBufferInheritanceInfo; TVkQueueFamilyProperties = record queueFlags: VkQueueFlags; queueCount: VkUint32; timestampValidBits: VkUint32; minImageTransferGranularity: TVkExtent3D; end; PVkQueueFamilyProperties = ^TVkQueueFamilyProperties; PPVkQueueFamilyProperties = ^PVkQueueFamilyProperties; TVkImageFormatProperties = record maxExtent: TVkExtent3D; maxMipLevels: VkUint32; maxArrayLayers: VkUint32; sampleCounts: VkSampleCountFlags; maxResourceSize: VkDeviceSize; end; PVkImageFormatProperties = ^TVkImageFormatProperties; PPVkImageFormatProperties = ^PVkImageFormatProperties; TVkDescriptorSetLayoutBinding = record binding: VkUint32; descriptorType: TVkDescriptorType; descriptorCount: VkUint32; stageFlags: VkShaderStageFlags; pImmutableSamplers: PVkSampler; end; PVkDescriptorSetLayoutBinding = ^TVkDescriptorSetLayoutBinding; PPVkDescriptorSetLayoutBinding = ^PVkDescriptorSetLayoutBinding; TVkSparseImageFormatProperties = record aspectMask: VkImageAspectFlags; imageGranularity: TVkExtent3D; flags: VkSparseImageFormatFlags; end; PVkSparseImageFormatProperties = ^TVkSparseImageFormatProperties; PPVkSparseImageFormatProperties = ^PVkSparseImageFormatProperties; TVkSparseImageMemoryBind = record subresource: TVkImageSubresource; offset: TVkOffset3D; extent: TVkExtent3D; memory: VkDeviceMemory; memoryOffset: VkDeviceSize; flags: VkSparseMemoryBindFlags; end; PVkSparseImageMemoryBind = ^TVkSparseImageMemoryBind; PPVkSparseImageMemoryBind = ^PVkSparseImageMemoryBind; TVkBufferImageCopy = record bufferOffset: VkDeviceSize; bufferRowLength: VkUint32; bufferImageHeight: VkUint32; imageSubresource: TVkImageSubresourceLayers; imageOffset: TVkOffset3D; imageExtent: TVkExtent3D; end; PVkBufferImageCopy = ^TVkBufferImageCopy; PPVkBufferImageCopy = ^PVkBufferImageCopy; TVkImageBlit = record srcSubresource: TVkImageSubresourceLayers; srcOffsets: array[0..2] of TVkOffset3D; dstSubresource: TVkImageSubresourceLayers; dstOffsets: array[0..2] of TVkOffset3D; end; PVkImageBlit = ^TVkImageBlit; PPVkImageBlit = ^PVkImageBlit; TVkImageCopy = record srcSubresource: TVkImageSubresourceLayers; srcOffset: TVkOffset3D; dstSubresource: TVkImageSubresourceLayers; dstOffset: TVkOffset3D; extent: TVkExtent3D; end; PVkImageCopy = ^TVkImageCopy; PPVkImageCopy = ^PVkImageCopy; TVkImageResolve = record srcSubresource: TVkImageSubresourceLayers; srcOffset: TVkOffset3D; dstSubresource: TVkImageSubresourceLayers; dstOffset: TVkOffset3D; extent: TVkExtent3D; end; PVkImageResolve = ^TVkImageResolve; PPVkImageResolve = ^PVkImageResolve; TVkPhysicalDeviceMemoryProperties = record memoryTypeCount: VkUint32; memoryTypes: array[0..VK_MAX_MEMORY_TYPES-1] of TVkMemoryType; memoryHeapCount: VkUint32; memoryHeaps: array[0..VK_MAX_MEMORY_HEAPS-1] of TVkMemoryHeap; end; PVkPhysicalDeviceMemoryProperties = ^TVkPhysicalDeviceMemoryProperties; PPVkPhysicalDeviceMemoryProperties = ^PVkPhysicalDeviceMemoryProperties; TVkPhysicalDeviceProperties = record apiVersion: VkUint32; driverVersion: VkUint32; vendorID: VkUint32; deviceID: VkUint32; deviceType: TVkPhysicalDeviceType; deviceName: array[0..VK_MAX_PHYSICAL_DEVICE_NAME_SIZE-1] of VkChar; pipelineCacheUUID: array[0..VK_UUID_SIZE-1] of VkUint8; limits: TVkPhysicalDeviceLimits; sparseProperties: TVkPhysicalDeviceSparseProperties; end; PVkPhysicalDeviceProperties = ^TVkPhysicalDeviceProperties; PPVkPhysicalDeviceProperties = ^PVkPhysicalDeviceProperties; TVkSparseBufferMemoryBindInfo = record buffer: VkBuffer; bindCount: VkUint32; pBinds: PVkSparseMemoryBind; end; PVkSparseBufferMemoryBindInfo = ^TVkSparseBufferMemoryBindInfo; PPVkSparseBufferMemoryBindInfo = ^PVkSparseBufferMemoryBindInfo; TVkSparseImageOpaqueMemoryBindInfo = record image: VkImage; bindCount: VkUint32; pBinds: PVkSparseMemoryBind; end; PVkSparseImageOpaqueMemoryBindInfo = ^TVkSparseImageOpaqueMemoryBindInfo; PPVkSparseImageOpaqueMemoryBindInfo = ^PVkSparseImageOpaqueMemoryBindInfo; TVkSubpassDescription = record flags: VkSubpassDescriptionFlags; pipelineBindPoint: TVkPipelineBindPoint; inputAttachmentCount: VkUint32; pInputAttachments: PVkAttachmentReference; colorAttachmentCount: VkUint32; pColorAttachments: PVkAttachmentReference; pResolveAttachments: PVkAttachmentReference; pDepthStencilAttachment: PVkAttachmentReference; preserveAttachmentCount: VkUint32; pPreserveAttachments: PVkUint32; end; PVkSubpassDescription = ^TVkSubpassDescription; PPVkSubpassDescription = ^PVkSubpassDescription; TVkDescriptorPoolCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkDescriptorPoolCreateFlags; maxSets: VkUint32; poolSizeCount: VkUint32; pPoolSizes: PVkDescriptorPoolSize; end; PVkDescriptorPoolCreateInfo = ^TVkDescriptorPoolCreateInfo; PPVkDescriptorPoolCreateInfo = ^PVkDescriptorPoolCreateInfo; TVkAllocationCallbacks = record pUserData: PVkVoid; pfnAllocation: TvkAllocationFunction; pfnReallocation: TvkReallocationFunction; pfnFree: TvkFreeFunction; pfnInternalAllocation: TvkInternalAllocationNotification; pfnInternalFree: TvkInternalFreeNotification; end; PVkAllocationCallbacks = ^TVkAllocationCallbacks; PPVkAllocationCallbacks = ^PVkAllocationCallbacks; TVkClearAttachment = record aspectMask: VkImageAspectFlags; colorAttachment: VkUint32; clearValue: TVkClearValue; end; PVkClearAttachment = ^TVkClearAttachment; PPVkClearAttachment = ^PVkClearAttachment; TVkClearRect = record rect: TVkRect2D; baseArrayLayer: VkUint32; layerCount: VkUint32; end; PVkClearRect = ^TVkClearRect; PPVkClearRect = ^PVkClearRect; TVkDeviceCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkDeviceCreateFlags; queueCreateInfoCount: VkUint32; pQueueCreateInfos: PVkDeviceQueueCreateInfo; enabledLayerCount: VkUint32; ppEnabledLayerNames: PPVkChar; enabledExtensionCount: VkUint32; ppEnabledExtensionNames: PPVkChar; pEnabledFeatures: PVkPhysicalDeviceFeatures; end; PVkDeviceCreateInfo = ^TVkDeviceCreateInfo; PPVkDeviceCreateInfo = ^PVkDeviceCreateInfo; TVkCommandBufferBeginInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkCommandBufferUsageFlags; pInheritanceInfo: PVkCommandBufferInheritanceInfo; end; PVkCommandBufferBeginInfo = ^TVkCommandBufferBeginInfo; PPVkCommandBufferBeginInfo = ^PVkCommandBufferBeginInfo; TVkDescriptorSetLayoutCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkDescriptorSetLayoutCreateFlags; bindingCount: VkUint32; pBindings: PVkDescriptorSetLayoutBinding; end; PVkDescriptorSetLayoutCreateInfo = ^TVkDescriptorSetLayoutCreateInfo; PPVkDescriptorSetLayoutCreateInfo = ^PVkDescriptorSetLayoutCreateInfo; TVkSparseImageMemoryRequirements = record formatProperties: TVkSparseImageFormatProperties; imageMipTailFirstLod: VkUint32; imageMipTailSize: VkDeviceSize; imageMipTailOffset: VkDeviceSize; imageMipTailStride: VkDeviceSize; end; PVkSparseImageMemoryRequirements = ^TVkSparseImageMemoryRequirements; PPVkSparseImageMemoryRequirements = ^PVkSparseImageMemoryRequirements; TVkSparseImageMemoryBindInfo = record image: VkImage; bindCount: VkUint32; pBinds: PVkSparseImageMemoryBind; end; PVkSparseImageMemoryBindInfo = ^TVkSparseImageMemoryBindInfo; PPVkSparseImageMemoryBindInfo = ^PVkSparseImageMemoryBindInfo; TVkBindSparseInfo = record sType: TVkStructureType; pNext: PVkVoid; waitSemaphoreCount: VkUint32; pWaitSemaphores: PVkSemaphore; bufferBindCount: VkUint32; pBufferBinds: PVkSparseBufferMemoryBindInfo; imageOpaqueBindCount: VkUint32; pImageOpaqueBinds: PVkSparseImageOpaqueMemoryBindInfo; imageBindCount: VkUint32; pImageBinds: PVkSparseImageMemoryBindInfo; signalSemaphoreCount: VkUint32; pSignalSemaphores: PVkSemaphore; end; PVkBindSparseInfo = ^TVkBindSparseInfo; PPVkBindSparseInfo = ^PVkBindSparseInfo; TVkMappedMemoryRange = record sType: TVkStructureType; pNext: PVkVoid; memory: VkDeviceMemory; offset: VkDeviceSize; size: VkDeviceSize; end; PVkMappedMemoryRange = ^TVkMappedMemoryRange; PPVkMappedMemoryRange = ^PVkMappedMemoryRange; TVkMemoryAllocateInfo = record sType: TVkStructureType; pNext: PVkVoid; allocationSize: VkDeviceSize; memoryTypeIndex: VkUint32; end; PVkMemoryAllocateInfo = ^TVkMemoryAllocateInfo; PPVkMemoryAllocateInfo = ^PVkMemoryAllocateInfo; TVkMemoryBarrier = record sType: TVkStructureType; pNext: PVkVoid; srcAccessMask: VkAccessFlags; dstAccessMask: VkAccessFlags; end; PVkMemoryBarrier = ^TVkMemoryBarrier; PPVkMemoryBarrier = ^PVkMemoryBarrier; TVkAttachmentDescription = record flags: VkAttachmentDescriptionFlags; format: TVkFormat; samples: TVkSampleCountFlagBits; loadOp: TVkAttachmentLoadOp; storeOp: TVkAttachmentStoreOp; stencilLoadOp: TVkAttachmentLoadOp; stencilStoreOp: TVkAttachmentStoreOp; initialLayout: TVkImageLayout; finalLayout: TVkImageLayout; end; PVkAttachmentDescription = ^TVkAttachmentDescription; PPVkAttachmentDescription = ^PVkAttachmentDescription; TVkEventCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkEventCreateFlags; end; PVkEventCreateInfo = ^TVkEventCreateInfo; PPVkEventCreateInfo = ^PVkEventCreateInfo; TVkFenceCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkFenceCreateFlags; end; PVkFenceCreateInfo = ^TVkFenceCreateInfo; PPVkFenceCreateInfo = ^PVkFenceCreateInfo; TVkFramebufferCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkFramebufferCreateFlags; renderPass: VkRenderPass; attachmentCount: VkUint32; pAttachments: PVkImageView; width: VkUint32; height: VkUint32; layers: VkUint32; end; PVkFramebufferCreateInfo = ^TVkFramebufferCreateInfo; PPVkFramebufferCreateInfo = ^PVkFramebufferCreateInfo; TVkImageCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkImageCreateFlags; imageType: TVkImageType; format: TVkFormat; extent: TVkExtent3D; mipLevels: VkUint32; arrayLayers: VkUint32; samples: TVkSampleCountFlagBits; tiling: TVkImageTiling; usage: VkImageUsageFlags; sharingMode: TVkSharingMode; queueFamilyIndexCount: VkUint32; pQueueFamilyIndices: PVkUint32; initialLayout: TVkImageLayout; end; PVkImageCreateInfo = ^TVkImageCreateInfo; PPVkImageCreateInfo = ^PVkImageCreateInfo; TVkPipelineCacheCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineCacheCreateFlags; initialDataSize: VkSize; pInitialData: PVkVoid; end; PVkPipelineCacheCreateInfo = ^TVkPipelineCacheCreateInfo; PPVkPipelineCacheCreateInfo = ^PVkPipelineCacheCreateInfo; TVkPipelineDynamicStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineDynamicStateCreateFlags; dynamicStateCount: VkUint32; pDynamicStates: PVkDynamicState; end; PVkPipelineDynamicStateCreateInfo = ^TVkPipelineDynamicStateCreateInfo; PPVkPipelineDynamicStateCreateInfo = ^PVkPipelineDynamicStateCreateInfo; TVkPipelineInputAssemblyStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineInputAssemblyStateCreateFlags; topology: TVkPrimitiveTopology; primitiveRestartEnable: VkBool32; end; PVkPipelineInputAssemblyStateCreateInfo = ^TVkPipelineInputAssemblyStateCreateInfo; PPVkPipelineInputAssemblyStateCreateInfo = ^PVkPipelineInputAssemblyStateCreateInfo; TVkPipelineMultisampleStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineMultisampleStateCreateFlags; rasterizationSamples: TVkSampleCountFlagBits; sampleShadingEnable: VkBool32; minSampleShading: VkFloat; pSampleMask: PVkSampleMask; alphaToCoverageEnable: VkBool32; alphaToOneEnable: VkBool32; end; PVkPipelineMultisampleStateCreateInfo = ^TVkPipelineMultisampleStateCreateInfo; PPVkPipelineMultisampleStateCreateInfo = ^PVkPipelineMultisampleStateCreateInfo; TVkPipelineRasterizationStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineRasterizationStateCreateFlags; depthClampEnable: VkBool32; rasterizerDiscardEnable: VkBool32; polygonMode: TVkPolygonMode; cullMode: VkCullModeFlags; frontFace: TVkFrontFace; depthBiasEnable: VkBool32; depthBiasConstantFactor: VkFloat; depthBiasClamp: VkFloat; depthBiasSlopeFactor: VkFloat; lineWidth: VkFloat; end; PVkPipelineRasterizationStateCreateInfo = ^TVkPipelineRasterizationStateCreateInfo; PPVkPipelineRasterizationStateCreateInfo = ^PVkPipelineRasterizationStateCreateInfo; TVkSubmitInfo = record sType: TVkStructureType; pNext: PVkVoid; waitSemaphoreCount: VkUint32; pWaitSemaphores: PVkSemaphore; pWaitDstStageMask: PVkPipelineStageFlags; commandBufferCount: VkUint32; pCommandBuffers: PVkCommandBuffer; signalSemaphoreCount: VkUint32; pSignalSemaphores: PVkSemaphore; end; PVkSubmitInfo = ^TVkSubmitInfo; PPVkSubmitInfo = ^PVkSubmitInfo; TVkPipelineTessellationStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineTessellationStateCreateFlags; patchControlPoints: VkUint32; end; PVkPipelineTessellationStateCreateInfo = ^TVkPipelineTessellationStateCreateInfo; PPVkPipelineTessellationStateCreateInfo = ^PVkPipelineTessellationStateCreateInfo; TVkQueryPoolCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkQueryPoolCreateFlags; queryType: TVkQueryType; queryCount: VkUint32; pipelineStatistics: VkQueryPipelineStatisticFlags; end; PVkQueryPoolCreateInfo = ^TVkQueryPoolCreateInfo; PPVkQueryPoolCreateInfo = ^PVkQueryPoolCreateInfo; TVkSamplerCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkSamplerCreateFlags; magFilter: TVkFilter; minFilter: TVkFilter; mipmapMode: TVkSamplerMipmapMode; addressModeU: TVkSamplerAddressMode; addressModeV: TVkSamplerAddressMode; addressModeW: TVkSamplerAddressMode; mipLodBias: VkFloat; anisotropyEnable: VkBool32; maxAnisotropy: VkFloat; compareEnable: VkBool32; compareOp: TVkCompareOp; minLod: VkFloat; maxLod: VkFloat; borderColor: TVkBorderColor; unnormalizedCoordinates: VkBool32; end; PVkSamplerCreateInfo = ^TVkSamplerCreateInfo; PPVkSamplerCreateInfo = ^PVkSamplerCreateInfo; TVkSemaphoreCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkSemaphoreCreateFlags; end; PVkSemaphoreCreateInfo = ^TVkSemaphoreCreateInfo; PPVkSemaphoreCreateInfo = ^PVkSemaphoreCreateInfo; TVkShaderModuleCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkShaderModuleCreateFlags; codeSize: VkSize; pCode: PVkUint32; end; PVkShaderModuleCreateInfo = ^TVkShaderModuleCreateInfo; PPVkShaderModuleCreateInfo = ^PVkShaderModuleCreateInfo; TVkImageMemoryBarrier = record sType: TVkStructureType; pNext: PVkVoid; srcAccessMask: VkAccessFlags; dstAccessMask: VkAccessFlags; oldLayout: TVkImageLayout; newLayout: TVkImageLayout; srcQueueFamilyIndex: VkUint32; dstQueueFamilyIndex: VkUint32; image: VkImage; subresourceRange: TVkImageSubresourceRange; end; PVkImageMemoryBarrier = ^TVkImageMemoryBarrier; PPVkImageMemoryBarrier = ^PVkImageMemoryBarrier; TVkPipelineLayoutCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineLayoutCreateFlags; setLayoutCount: VkUint32; pSetLayouts: PVkDescriptorSetLayout; pushConstantRangeCount: VkUint32; pPushConstantRanges: PVkPushConstantRange; end; PVkPipelineLayoutCreateInfo = ^TVkPipelineLayoutCreateInfo; PPVkPipelineLayoutCreateInfo = ^PVkPipelineLayoutCreateInfo; TVkImageViewCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkImageViewCreateFlags; image: VkImage; viewType: TVkImageViewType; format: TVkFormat; components: TVkComponentMapping; subresourceRange: TVkImageSubresourceRange; end; PVkImageViewCreateInfo = ^TVkImageViewCreateInfo; PPVkImageViewCreateInfo = ^PVkImageViewCreateInfo; TVkPipelineDepthStencilStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineDepthStencilStateCreateFlags; depthTestEnable: VkBool32; depthWriteEnable: VkBool32; depthCompareOp: TVkCompareOp; depthBoundsTestEnable: VkBool32; stencilTestEnable: VkBool32; front: TVkStencilOpState; back: TVkStencilOpState; minDepthBounds: VkFloat; maxDepthBounds: VkFloat; end; PVkPipelineDepthStencilStateCreateInfo = ^TVkPipelineDepthStencilStateCreateInfo; PPVkPipelineDepthStencilStateCreateInfo = ^PVkPipelineDepthStencilStateCreateInfo; TVkPipelineVertexInputStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineVertexInputStateCreateFlags; vertexBindingDescriptionCount: VkUint32; pVertexBindingDescriptions: PVkVertexInputBindingDescription; vertexAttributeDescriptionCount: VkUint32; pVertexAttributeDescriptions: PVkVertexInputAttributeDescription; end; PVkPipelineVertexInputStateCreateInfo = ^TVkPipelineVertexInputStateCreateInfo; PPVkPipelineVertexInputStateCreateInfo = ^PVkPipelineVertexInputStateCreateInfo; TVkInstanceCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkInstanceCreateFlags; pApplicationInfo: PVkApplicationInfo; enabledLayerCount: VkUint32; ppEnabledLayerNames: PPVkChar; enabledExtensionCount: VkUint32; ppEnabledExtensionNames: PPVkChar; end; PVkInstanceCreateInfo = ^TVkInstanceCreateInfo; PPVkInstanceCreateInfo = ^PVkInstanceCreateInfo; TVkWriteDescriptorSet = record sType: TVkStructureType; pNext: PVkVoid; dstSet: VkDescriptorSet; dstBinding: VkUint32; dstArrayElement: VkUint32; descriptorCount: VkUint32; descriptorType: TVkDescriptorType; pImageInfo: PVkDescriptorImageInfo; pBufferInfo: PVkDescriptorBufferInfo; pTexelBufferView: PVkBufferView; end; PVkWriteDescriptorSet = ^TVkWriteDescriptorSet; PPVkWriteDescriptorSet = ^PVkWriteDescriptorSet; TVkPipelineViewportStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineViewportStateCreateFlags; viewportCount: VkUint32; pViewports: PVkViewport; scissorCount: VkUint32; pScissors: PVkRect2D; end; PVkPipelineViewportStateCreateInfo = ^TVkPipelineViewportStateCreateInfo; PPVkPipelineViewportStateCreateInfo = ^PVkPipelineViewportStateCreateInfo; TVkRenderPassBeginInfo = record sType: TVkStructureType; pNext: PVkVoid; renderPass: VkRenderPass; framebuffer: VkFramebuffer; renderArea: TVkRect2D; clearValueCount: VkUint32; pClearValues: PVkClearValue; end; PVkRenderPassBeginInfo = ^TVkRenderPassBeginInfo; PPVkRenderPassBeginInfo = ^PVkRenderPassBeginInfo; TVkPipelineShaderStageCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineShaderStageCreateFlags; stage: TVkShaderStageFlagBits; module: VkShaderModule; pName: PVkChar; pSpecializationInfo: PVkSpecializationInfo; end; PVkPipelineShaderStageCreateInfo = ^TVkPipelineShaderStageCreateInfo; PPVkPipelineShaderStageCreateInfo = ^PVkPipelineShaderStageCreateInfo; TVkPipelineColorBlendStateCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineColorBlendStateCreateFlags; logicOpEnable: VkBool32; logicOp: TVkLogicOp; attachmentCount: VkUint32; pAttachments: PVkPipelineColorBlendAttachmentState; blendConstants: array[0..4] of VkFloat; end; PVkPipelineColorBlendStateCreateInfo = ^TVkPipelineColorBlendStateCreateInfo; PPVkPipelineColorBlendStateCreateInfo = ^PVkPipelineColorBlendStateCreateInfo; TVkRenderPassCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkRenderPassCreateFlags; attachmentCount: VkUint32; pAttachments: PVkAttachmentDescription; subpassCount: VkUint32; pSubpasses: PVkSubpassDescription; dependencyCount: VkUint32; pDependencies: PVkSubpassDependency; end; PVkRenderPassCreateInfo = ^TVkRenderPassCreateInfo; PPVkRenderPassCreateInfo = ^PVkRenderPassCreateInfo; TVkComputePipelineCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineCreateFlags; stage: TVkPipelineShaderStageCreateInfo; layout: VkPipelineLayout; basePipelineHandle: VkPipeline; basePipelineIndex: VkInt32; end; PVkComputePipelineCreateInfo = ^TVkComputePipelineCreateInfo; PPVkComputePipelineCreateInfo = ^PVkComputePipelineCreateInfo; TVkGraphicsPipelineCreateInfo = record sType: TVkStructureType; pNext: PVkVoid; flags: VkPipelineCreateFlags; stageCount: VkUint32; pStages: PVkPipelineShaderStageCreateInfo; pVertexInputState: PVkPipelineVertexInputStateCreateInfo; pInputAssemblyState: PVkPipelineInputAssemblyStateCreateInfo; pTessellationState: PVkPipelineTessellationStateCreateInfo; pViewportState: PVkPipelineViewportStateCreateInfo; pRasterizationState: PVkPipelineRasterizationStateCreateInfo; pMultisampleState: PVkPipelineMultisampleStateCreateInfo; pDepthStencilState: PVkPipelineDepthStencilStateCreateInfo; pColorBlendState: PVkPipelineColorBlendStateCreateInfo; pDynamicState: PVkPipelineDynamicStateCreateInfo; layout: VkPipelineLayout; renderPass: VkRenderPass; subpass: VkUint32; basePipelineHandle: VkPipeline; basePipelineIndex: VkInt32; end; PVkGraphicsPipelineCreateInfo = ^TVkGraphicsPipelineCreateInfo; PPVkGraphicsPipelineCreateInfo = ^PVkGraphicsPipelineCreateInfo; type { commands } TvkCmdDispatch = procedure(commandBuffer: VkCommandBuffer; x: VkUint32; y: VkUint32; z: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdDraw = procedure(commandBuffer: VkCommandBuffer; vertexCount: VkUint32; instanceCount: VkUint32; firstVertex: VkUint32; firstInstance: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdDrawIndexed = procedure(commandBuffer: VkCommandBuffer; indexCount: VkUint32; instanceCount: VkUint32; firstIndex: VkUint32; vertexOffset: VkInt32; firstInstance: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdEndRenderPass = procedure(commandBuffer: VkCommandBuffer); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdExecuteCommands = procedure(commandBuffer: VkCommandBuffer; commandBufferCount: VkUint32; const pCommandBuffers: PVkCommandBuffer); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetBlendConstants = procedure(commandBuffer: VkCommandBuffer; const blendConstants: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetDepthBias = procedure(commandBuffer: VkCommandBuffer; depthBiasConstantFactor: VkFloat; depthBiasClamp: VkFloat; depthBiasSlopeFactor: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetDepthBounds = procedure(commandBuffer: VkCommandBuffer; minDepthBounds: VkFloat; maxDepthBounds: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDeviceWaitIdle = function (device: VkDevice): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetDeviceProcAddr = function (device: VkDevice; const pName: PVkChar): TvkVoidFunction; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetInstanceProcAddr = function (instance: VkInstance; const pName: PVkChar): TvkVoidFunction; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkEnumeratePhysicalDevices = function (instance: VkInstance; pPhysicalDeviceCount: PVkUint32; pPhysicalDevices: PVkPhysicalDevice): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetDeviceQueue = procedure(device: VkDevice; queueFamilyIndex: VkUint32; queueIndex: VkUint32; pQueue: PVkQueue); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkQueueWaitIdle = function (queue: VkQueue): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetLineWidth = procedure(commandBuffer: VkCommandBuffer; lineWidth: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkEndCommandBuffer = function (commandBuffer: VkCommandBuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkFreeCommandBuffers = procedure(device: VkDevice; commandPool: VkCommandPool; commandBufferCount: VkUint32; const pCommandBuffers: PVkCommandBuffer); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkFreeDescriptorSets = function (device: VkDevice; descriptorPool: VkDescriptorPool; descriptorSetCount: VkUint32; const pDescriptorSets: PVkDescriptorSet): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkUnmapMemory = procedure(device: VkDevice; memory: VkDeviceMemory); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetEventStatus = function (device: VkDevice; event: VkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkResetEvent = function (device: VkDevice; event: VkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkSetEvent = function (device: VkDevice; event: VkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetFenceStatus = function (device: VkDevice; fence: VkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkResetFences = function (device: VkDevice; fenceCount: VkUint32; const pFences: PVkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPipelineCacheData = function (device: VkDevice; pipelineCache: VkPipelineCache; pDataSize: PVkSize; pData: PVkVoid): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkMergePipelineCaches = function (device: VkDevice; dstCache: VkPipelineCache; srcCacheCount: VkUint32; const pSrcCaches: PVkPipelineCache): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdEndQuery = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; query: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdResetQueryPool = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; firstQuery: VkUint32; queryCount: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkWaitForFences = function (device: VkDevice; fenceCount: VkUint32; const pFences: PVkFence; waitAll: VkBool32; timeout: VkUint64): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkBindBufferMemory = function (device: VkDevice; buffer: VkBuffer; memory: VkDeviceMemory; memoryOffset: VkDeviceSize): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkBindImageMemory = function (device: VkDevice; image: VkImage; memory: VkDeviceMemory; memoryOffset: VkDeviceSize): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBindVertexBuffers = procedure(commandBuffer: VkCommandBuffer; firstBinding: VkUint32; bindingCount: VkUint32; const pBuffers: PVkBuffer; const pOffsets: PVkDeviceSize); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdDispatchIndirect = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdDrawIndexedIndirect = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize; drawCount: VkUint32; stride: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdDrawIndirect = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize; drawCount: VkUint32; stride: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdFillBuffer = procedure(commandBuffer: VkCommandBuffer; dstBuffer: VkBuffer; dstOffset: VkDeviceSize; size: VkDeviceSize; data: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdUpdateBuffer = procedure(commandBuffer: VkCommandBuffer; dstBuffer: VkBuffer; dstOffset: VkDeviceSize; dataSize: VkDeviceSize; const pData: PVkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetDeviceMemoryCommitment = procedure(device: VkDevice; memory: VkDeviceMemory; pCommittedMemoryInBytes: PVkDeviceSize); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkResetCommandBuffer = function (commandBuffer: VkCommandBuffer; flags: VkCommandBufferResetFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkResetCommandPool = function (device: VkDevice; commandPool: VkCommandPool; flags: VkCommandPoolResetFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkResetDescriptorPool = function (device: VkDevice; descriptorPool: VkDescriptorPool; flags: VkDescriptorPoolResetFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkMapMemory = function (device: VkDevice; memory: VkDeviceMemory; offset: VkDeviceSize; size: VkDeviceSize; flags: VkMemoryMapFlags; ppData: PPVkVoid): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdResetEvent = procedure(commandBuffer: VkCommandBuffer; event: VkEvent; stageMask: VkPipelineStageFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetEvent = procedure(commandBuffer: VkCommandBuffer; event: VkEvent; stageMask: VkPipelineStageFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBeginQuery = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; query: VkUint32; flags: VkQueryControlFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdCopyQueryPoolResults = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; firstQuery: VkUint32; queryCount: VkUint32; dstBuffer: VkBuffer; dstOffset: VkDeviceSize; stride: VkDeviceSize; flags: VkQueryResultFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetQueryPoolResults = function (device: VkDevice; queryPool: VkQueryPool; firstQuery: VkUint32; queryCount: VkUint32; dataSize: VkSize; pData: PVkVoid; stride: VkDeviceSize; flags: VkQueryResultFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdPushConstants = procedure(commandBuffer: VkCommandBuffer; layout: VkPipelineLayout; stageFlags: VkShaderStageFlags; offset: VkUint32; size: VkUint32; const pValues: PVkVoid); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetStencilCompareMask = procedure(commandBuffer: VkCommandBuffer; faceMask: VkStencilFaceFlags; compareMask: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetStencilReference = procedure(commandBuffer: VkCommandBuffer; faceMask: VkStencilFaceFlags; reference: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetStencilWriteMask = procedure(commandBuffer: VkCommandBuffer; faceMask: VkStencilFaceFlags; writeMask: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBindPipeline = procedure(commandBuffer: VkCommandBuffer; pipelineBindPoint: TVkPipelineBindPoint; pipeline: VkPipeline); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBindDescriptorSets = procedure(commandBuffer: VkCommandBuffer; pipelineBindPoint: TVkPipelineBindPoint; layout: VkPipelineLayout; firstSet: VkUint32; descriptorSetCount: VkUint32; const pDescriptorSets: PVkDescriptorSet; dynamicOffsetCount: VkUint32; const pDynamicOffsets: PVkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetViewport = procedure(commandBuffer: VkCommandBuffer; firstViewport: VkUint32; viewportCount: VkUint32; const pViewports: PVkViewport); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkEnumerateDeviceExtensionProperties = function (physicalDevice: VkPhysicalDevice; const pLayerName: PVkChar; pPropertyCount: PVkUint32; pProperties: PVkExtensionProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkEnumerateInstanceExtensionProperties = function (const pLayerName: PVkChar; pPropertyCount: PVkUint32; pProperties: PVkExtensionProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetRenderAreaGranularity = procedure(device: VkDevice; renderPass: VkRenderPass; pGranularity: PVkExtent2D); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkEnumerateDeviceLayerProperties = function (physicalDevice: VkPhysicalDevice; pPropertyCount: PVkUint32; pProperties: PVkLayerProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkEnumerateInstanceLayerProperties = function (pPropertyCount: PVkUint32; pProperties: PVkLayerProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBindIndexBuffer = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize; indexType: TVkIndexType); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceFeatures = procedure(physicalDevice: VkPhysicalDevice; pFeatures: PVkPhysicalDeviceFeatures); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdCopyBuffer = procedure(commandBuffer: VkCommandBuffer; srcBuffer: VkBuffer; dstBuffer: VkBuffer; regionCount: VkUint32; const pRegions: PVkBufferCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetBufferMemoryRequirements = procedure(device: VkDevice; buffer: VkBuffer; pMemoryRequirements: PVkMemoryRequirements); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetImageMemoryRequirements = procedure(device: VkDevice; image: VkImage; pMemoryRequirements: PVkMemoryRequirements); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceFormatProperties = procedure(physicalDevice: VkPhysicalDevice; format: TVkFormat; pFormatProperties: PVkFormatProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetImageSubresourceLayout = procedure(device: VkDevice; image: VkImage; const pSubresource: PVkImageSubresource; pLayout: PVkSubresourceLayout); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdClearColorImage = procedure(commandBuffer: VkCommandBuffer; image: VkImage; imageLayout: TVkImageLayout; const pColor: PVkClearColorValue; rangeCount: VkUint32; const pRanges: PVkImageSubresourceRange); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdClearDepthStencilImage = procedure(commandBuffer: VkCommandBuffer; image: VkImage; imageLayout: TVkImageLayout; const pDepthStencil: PVkClearDepthStencilValue; rangeCount: VkUint32; const pRanges: PVkImageSubresourceRange); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkAllocateCommandBuffers = function (device: VkDevice; const pAllocateInfo: PVkCommandBufferAllocateInfo; pCommandBuffers: PVkCommandBuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkAllocateDescriptorSets = function (device: VkDevice; const pAllocateInfo: PVkDescriptorSetAllocateInfo; pDescriptorSets: PVkDescriptorSet): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdSetScissor = procedure(commandBuffer: VkCommandBuffer; firstScissor: VkUint32; scissorCount: VkUint32; const pScissors: PVkRect2D); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceQueueFamilyProperties = procedure(physicalDevice: VkPhysicalDevice; pQueueFamilyPropertyCount: PVkUint32; pQueueFamilyProperties: PVkQueueFamilyProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceImageFormatProperties = function (physicalDevice: VkPhysicalDevice; format: TVkFormat; iType: TVkImageType; tiling: TVkImageTiling; usage: VkImageUsageFlags; flags: VkImageCreateFlags; pImageFormatProperties: PVkImageFormatProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdCopyImage = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkImageCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateBuffer = function (device: VkDevice; const pCreateInfo: PVkBufferCreateInfo; const pAllocator: PVkAllocationCallbacks; pBuffer: PVkBuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateBufferView = function (device: VkDevice; const pCreateInfo: PVkBufferViewCreateInfo; const pAllocator: PVkAllocationCallbacks; pView: PVkBufferView): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateCommandPool = function (device: VkDevice; const pCreateInfo: PVkCommandPoolCreateInfo; const pAllocator: PVkAllocationCallbacks; pCommandPool: PVkCommandPool): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyBuffer = procedure(device: VkDevice; buffer: VkBuffer; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyBufferView = procedure(device: VkDevice; bufferView: VkBufferView; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyCommandPool = procedure(device: VkDevice; commandPool: VkCommandPool; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdCopyBufferToImage = procedure(commandBuffer: VkCommandBuffer; srcBuffer: VkBuffer; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkBufferImageCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBlitImage = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkImageBlit; filter: TVkFilter); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkQueueBindSparse = function (queue: VkQueue; bindInfoCount: VkUint32; const pBindInfo: PVkBindSparseInfo; fence: VkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdCopyImageToBuffer = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstBuffer: VkBuffer; regionCount: VkUint32; const pRegions: PVkBufferImageCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdResolveImage = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkImageResolve); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceMemoryProperties = procedure(physicalDevice: VkPhysicalDevice; pMemoryProperties: PVkPhysicalDeviceMemoryProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateDescriptorPool = function (device: VkDevice; const pCreateInfo: PVkDescriptorPoolCreateInfo; const pAllocator: PVkAllocationCallbacks; pDescriptorPool: PVkDescriptorPool): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateDevice = function (physicalDevice: VkPhysicalDevice; const pCreateInfo: PVkDeviceCreateInfo; const pAllocator: PVkAllocationCallbacks; pDevice: PVkDevice): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateDescriptorSetLayout = function (device: VkDevice; const pCreateInfo: PVkDescriptorSetLayoutCreateInfo; const pAllocator: PVkAllocationCallbacks; pSetLayout: PVkDescriptorSetLayout): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetImageSparseMemoryRequirements = procedure(device: VkDevice; image: VkImage; pSparseMemoryRequirementCount: PVkUint32; pSparseMemoryRequirements: PVkSparseImageMemoryRequirements); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyDescriptorPool = procedure(device: VkDevice; descriptorPool: VkDescriptorPool; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyDescriptorSetLayout = procedure(device: VkDevice; descriptorSetLayout: VkDescriptorSetLayout; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyDevice = procedure(device: VkDevice; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyEvent = procedure(device: VkDevice; event: VkEvent; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyFence = procedure(device: VkDevice; fence: VkFence; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyFramebuffer = procedure(device: VkDevice; framebuffer: VkFramebuffer; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyImage = procedure(device: VkDevice; image: VkImage; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyImageView = procedure(device: VkDevice; imageView: VkImageView; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyInstance = procedure(instance: VkInstance; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyPipeline = procedure(device: VkDevice; pipeline: VkPipeline; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyPipelineCache = procedure(device: VkDevice; pipelineCache: VkPipelineCache; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyPipelineLayout = procedure(device: VkDevice; pipelineLayout: VkPipelineLayout; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceProperties = procedure(physicalDevice: VkPhysicalDevice; pProperties: PVkPhysicalDeviceProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyQueryPool = procedure(device: VkDevice; queryPool: VkQueryPool; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyRenderPass = procedure(device: VkDevice; renderPass: VkRenderPass; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroySampler = procedure(device: VkDevice; sampler: VkSampler; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroySemaphore = procedure(device: VkDevice; semaphore: VkSemaphore; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkDestroyShaderModule = procedure(device: VkDevice; shaderModule: VkShaderModule; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkFreeMemory = procedure(device: VkDevice; memory: VkDeviceMemory; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdClearAttachments = procedure(commandBuffer: VkCommandBuffer; attachmentCount: VkUint32; const pAttachments: PVkClearAttachment; rectCount: VkUint32; const pRects: PVkClearRect); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkBeginCommandBuffer = function (commandBuffer: VkCommandBuffer; const pBeginInfo: PVkCommandBufferBeginInfo): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdNextSubpass = procedure(commandBuffer: VkCommandBuffer; contents: TVkSubpassContents); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdWriteTimestamp = procedure(commandBuffer: VkCommandBuffer; pipelineStage: TVkPipelineStageFlagBits; queryPool: VkQueryPool; query: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkGetPhysicalDeviceSparseImageFormatProperties = procedure(physicalDevice: VkPhysicalDevice; format: TVkFormat; iType: TVkImageType; samples: TVkSampleCountFlagBits; usage: VkImageUsageFlags; tiling: TVkImageTiling; pPropertyCount: PVkUint32; pProperties: PVkSparseImageFormatProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkFlushMappedMemoryRanges = function (device: VkDevice; memoryRangeCount: VkUint32; const pMemoryRanges: PVkMappedMemoryRange): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkInvalidateMappedMemoryRanges = function (device: VkDevice; memoryRangeCount: VkUint32; const pMemoryRanges: PVkMappedMemoryRange): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkAllocateMemory = function (device: VkDevice; const pAllocateInfo: PVkMemoryAllocateInfo; const pAllocator: PVkAllocationCallbacks; pMemory: PVkDeviceMemory): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateEvent = function (device: VkDevice; const pCreateInfo: PVkEventCreateInfo; const pAllocator: PVkAllocationCallbacks; pEvent: PVkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateFence = function (device: VkDevice; const pCreateInfo: PVkFenceCreateInfo; const pAllocator: PVkAllocationCallbacks; pFence: PVkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateFramebuffer = function (device: VkDevice; const pCreateInfo: PVkFramebufferCreateInfo; const pAllocator: PVkAllocationCallbacks; pFramebuffer: PVkFramebuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateImage = function (device: VkDevice; const pCreateInfo: PVkImageCreateInfo; const pAllocator: PVkAllocationCallbacks; pImage: PVkImage): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreatePipelineCache = function (device: VkDevice; const pCreateInfo: PVkPipelineCacheCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelineCache: PVkPipelineCache): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkQueueSubmit = function (queue: VkQueue; submitCount: VkUint32; const pSubmits: PVkSubmitInfo; fence: VkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateQueryPool = function (device: VkDevice; const pCreateInfo: PVkQueryPoolCreateInfo; const pAllocator: PVkAllocationCallbacks; pQueryPool: PVkQueryPool): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateSampler = function (device: VkDevice; const pCreateInfo: PVkSamplerCreateInfo; const pAllocator: PVkAllocationCallbacks; pSampler: PVkSampler): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateSemaphore = function (device: VkDevice; const pCreateInfo: PVkSemaphoreCreateInfo; const pAllocator: PVkAllocationCallbacks; pSemaphore: PVkSemaphore): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateShaderModule = function (device: VkDevice; const pCreateInfo: PVkShaderModuleCreateInfo; const pAllocator: PVkAllocationCallbacks; pShaderModule: PVkShaderModule): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdPipelineBarrier = procedure(commandBuffer: VkCommandBuffer; srcStageMask: VkPipelineStageFlags; dstStageMask: VkPipelineStageFlags; dependencyFlags: VkDependencyFlags; memoryBarrierCount: VkUint32; const pMemoryBarriers: PVkMemoryBarrier; bufferMemoryBarrierCount: VkUint32; const pBufferMemoryBarriers: PVkBufferMemoryBarrier; imageMemoryBarrierCount: VkUint32; const pImageMemoryBarriers: PVkImageMemoryBarrier); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdWaitEvents = procedure(commandBuffer: VkCommandBuffer; eventCount: VkUint32; const pEvents: PVkEvent; srcStageMask: VkPipelineStageFlags; dstStageMask: VkPipelineStageFlags; memoryBarrierCount: VkUint32; const pMemoryBarriers: PVkMemoryBarrier; bufferMemoryBarrierCount: VkUint32; const pBufferMemoryBarriers: PVkBufferMemoryBarrier; imageMemoryBarrierCount: VkUint32; const pImageMemoryBarriers: PVkImageMemoryBarrier); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreatePipelineLayout = function (device: VkDevice; const pCreateInfo: PVkPipelineLayoutCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelineLayout: PVkPipelineLayout): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateImageView = function (device: VkDevice; const pCreateInfo: PVkImageViewCreateInfo; const pAllocator: PVkAllocationCallbacks; pView: PVkImageView): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateInstance = function (const pCreateInfo: PVkInstanceCreateInfo; const pAllocator: PVkAllocationCallbacks; pInstance: PVkInstance): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkUpdateDescriptorSets = procedure(device: VkDevice; descriptorWriteCount: VkUint32; const pDescriptorWrites: PVkWriteDescriptorSet; descriptorCopyCount: VkUint32; const pDescriptorCopies: PVkCopyDescriptorSet); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCmdBeginRenderPass = procedure(commandBuffer: VkCommandBuffer; const pRenderPassBegin: PVkRenderPassBeginInfo; contents: TVkSubpassContents); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateRenderPass = function (device: VkDevice; const pCreateInfo: PVkRenderPassCreateInfo; const pAllocator: PVkAllocationCallbacks; pRenderPass: PVkRenderPass): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateGraphicsPipelines = function (device: VkDevice; pipelineCache: VkPipelineCache; createInfoCount: VkUint32; const pCreateInfos: PVkGraphicsPipelineCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelines: PVkPipeline): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; TvkCreateComputePipelines = function (device: VkDevice; pipelineCache: VkPipelineCache; createInfoCount: VkUint32; const pCreateInfos: PVkComputePipelineCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelines: PVkPipeline): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF}; var { command variables } vkCmdDispatch: TvkCmdDispatch = nil; vkCmdDraw: TvkCmdDraw = nil; vkCmdDrawIndexed: TvkCmdDrawIndexed = nil; vkCmdEndRenderPass: TvkCmdEndRenderPass = nil; vkCmdExecuteCommands: TvkCmdExecuteCommands = nil; vkCmdSetBlendConstants: TvkCmdSetBlendConstants = nil; vkCmdSetDepthBias: TvkCmdSetDepthBias = nil; vkCmdSetDepthBounds: TvkCmdSetDepthBounds = nil; vkDeviceWaitIdle: TvkDeviceWaitIdle = nil; vkGetDeviceProcAddr: TvkGetDeviceProcAddr = nil; vkGetInstanceProcAddr: TvkGetInstanceProcAddr = nil; vkEnumeratePhysicalDevices: TvkEnumeratePhysicalDevices = nil; vkGetDeviceQueue: TvkGetDeviceQueue = nil; vkQueueWaitIdle: TvkQueueWaitIdle = nil; vkCmdSetLineWidth: TvkCmdSetLineWidth = nil; vkEndCommandBuffer: TvkEndCommandBuffer = nil; vkFreeCommandBuffers: TvkFreeCommandBuffers = nil; vkFreeDescriptorSets: TvkFreeDescriptorSets = nil; vkUnmapMemory: TvkUnmapMemory = nil; vkGetEventStatus: TvkGetEventStatus = nil; vkResetEvent: TvkResetEvent = nil; vkSetEvent: TvkSetEvent = nil; vkGetFenceStatus: TvkGetFenceStatus = nil; vkResetFences: TvkResetFences = nil; vkGetPipelineCacheData: TvkGetPipelineCacheData = nil; vkMergePipelineCaches: TvkMergePipelineCaches = nil; vkCmdEndQuery: TvkCmdEndQuery = nil; vkCmdResetQueryPool: TvkCmdResetQueryPool = nil; vkWaitForFences: TvkWaitForFences = nil; vkBindBufferMemory: TvkBindBufferMemory = nil; vkBindImageMemory: TvkBindImageMemory = nil; vkCmdBindVertexBuffers: TvkCmdBindVertexBuffers = nil; vkCmdDispatchIndirect: TvkCmdDispatchIndirect = nil; vkCmdDrawIndexedIndirect: TvkCmdDrawIndexedIndirect = nil; vkCmdDrawIndirect: TvkCmdDrawIndirect = nil; vkCmdFillBuffer: TvkCmdFillBuffer = nil; vkCmdUpdateBuffer: TvkCmdUpdateBuffer = nil; vkGetDeviceMemoryCommitment: TvkGetDeviceMemoryCommitment = nil; vkResetCommandBuffer: TvkResetCommandBuffer = nil; vkResetCommandPool: TvkResetCommandPool = nil; vkResetDescriptorPool: TvkResetDescriptorPool = nil; vkMapMemory: TvkMapMemory = nil; vkCmdResetEvent: TvkCmdResetEvent = nil; vkCmdSetEvent: TvkCmdSetEvent = nil; vkCmdBeginQuery: TvkCmdBeginQuery = nil; vkCmdCopyQueryPoolResults: TvkCmdCopyQueryPoolResults = nil; vkGetQueryPoolResults: TvkGetQueryPoolResults = nil; vkCmdPushConstants: TvkCmdPushConstants = nil; vkCmdSetStencilCompareMask: TvkCmdSetStencilCompareMask = nil; vkCmdSetStencilReference: TvkCmdSetStencilReference = nil; vkCmdSetStencilWriteMask: TvkCmdSetStencilWriteMask = nil; vkCmdBindPipeline: TvkCmdBindPipeline = nil; vkCmdBindDescriptorSets: TvkCmdBindDescriptorSets = nil; vkCmdSetViewport: TvkCmdSetViewport = nil; vkEnumerateDeviceExtensionProperties: TvkEnumerateDeviceExtensionProperties = nil; vkEnumerateInstanceExtensionProperties: TvkEnumerateInstanceExtensionProperties = nil; vkGetRenderAreaGranularity: TvkGetRenderAreaGranularity = nil; vkEnumerateDeviceLayerProperties: TvkEnumerateDeviceLayerProperties = nil; vkEnumerateInstanceLayerProperties: TvkEnumerateInstanceLayerProperties = nil; vkCmdBindIndexBuffer: TvkCmdBindIndexBuffer = nil; vkGetPhysicalDeviceFeatures: TvkGetPhysicalDeviceFeatures = nil; vkCmdCopyBuffer: TvkCmdCopyBuffer = nil; vkGetBufferMemoryRequirements: TvkGetBufferMemoryRequirements = nil; vkGetImageMemoryRequirements: TvkGetImageMemoryRequirements = nil; vkGetPhysicalDeviceFormatProperties: TvkGetPhysicalDeviceFormatProperties = nil; vkGetImageSubresourceLayout: TvkGetImageSubresourceLayout = nil; vkCmdClearColorImage: TvkCmdClearColorImage = nil; vkCmdClearDepthStencilImage: TvkCmdClearDepthStencilImage = nil; vkAllocateCommandBuffers: TvkAllocateCommandBuffers = nil; vkAllocateDescriptorSets: TvkAllocateDescriptorSets = nil; vkCmdSetScissor: TvkCmdSetScissor = nil; vkGetPhysicalDeviceQueueFamilyProperties: TvkGetPhysicalDeviceQueueFamilyProperties = nil; vkGetPhysicalDeviceImageFormatProperties: TvkGetPhysicalDeviceImageFormatProperties = nil; vkCmdCopyImage: TvkCmdCopyImage = nil; vkCreateBuffer: TvkCreateBuffer = nil; vkCreateBufferView: TvkCreateBufferView = nil; vkCreateCommandPool: TvkCreateCommandPool = nil; vkDestroyBuffer: TvkDestroyBuffer = nil; vkDestroyBufferView: TvkDestroyBufferView = nil; vkDestroyCommandPool: TvkDestroyCommandPool = nil; vkCmdCopyBufferToImage: TvkCmdCopyBufferToImage = nil; vkCmdBlitImage: TvkCmdBlitImage = nil; vkQueueBindSparse: TvkQueueBindSparse = nil; vkCmdCopyImageToBuffer: TvkCmdCopyImageToBuffer = nil; vkCmdResolveImage: TvkCmdResolveImage = nil; vkGetPhysicalDeviceMemoryProperties: TvkGetPhysicalDeviceMemoryProperties = nil; vkCreateDescriptorPool: TvkCreateDescriptorPool = nil; vkCreateDevice: TvkCreateDevice = nil; vkCreateDescriptorSetLayout: TvkCreateDescriptorSetLayout = nil; vkGetImageSparseMemoryRequirements: TvkGetImageSparseMemoryRequirements = nil; vkDestroyDescriptorPool: TvkDestroyDescriptorPool = nil; vkDestroyDescriptorSetLayout: TvkDestroyDescriptorSetLayout = nil; vkDestroyDevice: TvkDestroyDevice = nil; vkDestroyEvent: TvkDestroyEvent = nil; vkDestroyFence: TvkDestroyFence = nil; vkDestroyFramebuffer: TvkDestroyFramebuffer = nil; vkDestroyImage: TvkDestroyImage = nil; vkDestroyImageView: TvkDestroyImageView = nil; vkDestroyInstance: TvkDestroyInstance = nil; vkDestroyPipeline: TvkDestroyPipeline = nil; vkDestroyPipelineCache: TvkDestroyPipelineCache = nil; vkDestroyPipelineLayout: TvkDestroyPipelineLayout = nil; vkGetPhysicalDeviceProperties: TvkGetPhysicalDeviceProperties = nil; vkDestroyQueryPool: TvkDestroyQueryPool = nil; vkDestroyRenderPass: TvkDestroyRenderPass = nil; vkDestroySampler: TvkDestroySampler = nil; vkDestroySemaphore: TvkDestroySemaphore = nil; vkDestroyShaderModule: TvkDestroyShaderModule = nil; vkFreeMemory: TvkFreeMemory = nil; vkCmdClearAttachments: TvkCmdClearAttachments = nil; vkBeginCommandBuffer: TvkBeginCommandBuffer = nil; vkCmdNextSubpass: TvkCmdNextSubpass = nil; vkCmdWriteTimestamp: TvkCmdWriteTimestamp = nil; vkGetPhysicalDeviceSparseImageFormatProperties: TvkGetPhysicalDeviceSparseImageFormatProperties = nil; vkFlushMappedMemoryRanges: TvkFlushMappedMemoryRanges = nil; vkInvalidateMappedMemoryRanges: TvkInvalidateMappedMemoryRanges = nil; vkAllocateMemory: TvkAllocateMemory = nil; vkCreateEvent: TvkCreateEvent = nil; vkCreateFence: TvkCreateFence = nil; vkCreateFramebuffer: TvkCreateFramebuffer = nil; vkCreateImage: TvkCreateImage = nil; vkCreatePipelineCache: TvkCreatePipelineCache = nil; vkQueueSubmit: TvkQueueSubmit = nil; vkCreateQueryPool: TvkCreateQueryPool = nil; vkCreateSampler: TvkCreateSampler = nil; vkCreateSemaphore: TvkCreateSemaphore = nil; vkCreateShaderModule: TvkCreateShaderModule = nil; vkCmdPipelineBarrier: TvkCmdPipelineBarrier = nil; vkCmdWaitEvents: TvkCmdWaitEvents = nil; vkCreatePipelineLayout: TvkCreatePipelineLayout = nil; vkCreateImageView: TvkCreateImageView = nil; vkCreateInstance: TvkCreateInstance = nil; vkUpdateDescriptorSets: TvkUpdateDescriptorSets = nil; vkCmdBeginRenderPass: TvkCmdBeginRenderPass = nil; vkCreateRenderPass: TvkCreateRenderPass = nil; vkCreateGraphicsPipelines: TvkCreateGraphicsPipelines = nil; vkCreateComputePipelines: TvkCreateComputePipelines = nil; const VULKAN_LIBNAME = 'vulkan-1.dll'; type VkVersion = VkInt32; function vkMakeVersion(const aMajor, aMinor, aPatch: Integer): VkVersion; function vkGetVersionMajor(const aVersion: VkVersion): Integer; function vkGetVersionMinor(const aVersion: VkVersion): Integer; function vkgetVersionPatch(const aVersion: VkVersion): Integer; function InitializeVulkan(const aLibName: String = VULKAN_LIBNAME): Boolean; procedure FinalizeVulkan; implementation type {$IF DEFINED(VK_WIN)} TvkLibHandle = TLibHandle; {$ELSE} TvkLibHandle = Pointer; {$ENDIF} const {$IF DEFINED(VK_WIN)} InvalidLibHandle = 0; {$ELSE} InvalidLibHandle = nil; {$ENDIF} var vkLibHandle: TvkLibHandle = InvalidLibHandle; function vkLoadLibrary(const aLibName: String): TvkLibHandle; begin {$IF DEFINED(VK_WIN)} result := LoadLibrary(aLibName); {$ELSE} result := InvalidLibHandle; {$ENDIF} end; function vkGetProcAddress(const aProcName: String; aLibHandle: TvkLibHandle = InvalidLibHandle): Pointer; begin if (aLibHandle = InvalidLibHandle) then aLibHandle := vkLibHandle; {$IF DEFINED(VK_WIN)} result := GetProcAddress(aLibHandle, AnsiString(aProcName)); {$ELSE} result := nil; {$ENDIF} end; procedure vkFreeLibrary(var aLibHandle: TvkLibHandle); begin if (aLibHandle <> InvalidLibHandle) then begin {$IF DEFINED(VK_WIN)} FreeLibrary(aLibHandle); {$ENDIF} aLibHandle := InvalidLibHandle; end; end; function vkMakeVersion(const aMajor, aMinor, aPatch: Integer): VkVersion; begin result := (aMajor shl 22) or (aMinor shl 12) or aPatch; end; function vkGetVersionMajor(const aVersion: VkVersion): Integer; begin result := (aVersion shr 22); end; function vkGetVersionMinor(const aVersion: VkVersion): Integer; begin result := (aVersion shr 12) and $3FF; end; function vkGetVersionPatch(const aVersion: VkVersion): Integer; begin result := (aVersion and $FFF); end; function InitializeVulkan(const aLibName: String = VULKAN_LIBNAME): Boolean; begin FinalizeVulkan; vkLibHandle := vkLoadLibrary(aLibName); result := (vkLibHandle <> InvalidLibHandle); if not result then exit; {********************************* VK_VERSION_1_0 *********************************} vkCmdDispatch := vkGetProcAddress('vkCmdDispatch'); vkCmdDraw := vkGetProcAddress('vkCmdDraw'); vkCmdDrawIndexed := vkGetProcAddress('vkCmdDrawIndexed'); vkCmdEndRenderPass := vkGetProcAddress('vkCmdEndRenderPass'); vkCmdExecuteCommands := vkGetProcAddress('vkCmdExecuteCommands'); vkCmdSetBlendConstants := vkGetProcAddress('vkCmdSetBlendConstants'); vkCmdSetDepthBias := vkGetProcAddress('vkCmdSetDepthBias'); vkCmdSetDepthBounds := vkGetProcAddress('vkCmdSetDepthBounds'); vkDeviceWaitIdle := vkGetProcAddress('vkDeviceWaitIdle'); vkGetDeviceProcAddr := vkGetProcAddress('vkGetDeviceProcAddr'); vkGetInstanceProcAddr := vkGetProcAddress('vkGetInstanceProcAddr'); vkEnumeratePhysicalDevices := vkGetProcAddress('vkEnumeratePhysicalDevices'); vkGetDeviceQueue := vkGetProcAddress('vkGetDeviceQueue'); vkQueueWaitIdle := vkGetProcAddress('vkQueueWaitIdle'); vkCmdSetLineWidth := vkGetProcAddress('vkCmdSetLineWidth'); vkEndCommandBuffer := vkGetProcAddress('vkEndCommandBuffer'); vkFreeCommandBuffers := vkGetProcAddress('vkFreeCommandBuffers'); vkFreeDescriptorSets := vkGetProcAddress('vkFreeDescriptorSets'); vkUnmapMemory := vkGetProcAddress('vkUnmapMemory'); vkGetEventStatus := vkGetProcAddress('vkGetEventStatus'); vkResetEvent := vkGetProcAddress('vkResetEvent'); vkSetEvent := vkGetProcAddress('vkSetEvent'); vkGetFenceStatus := vkGetProcAddress('vkGetFenceStatus'); vkResetFences := vkGetProcAddress('vkResetFences'); vkGetPipelineCacheData := vkGetProcAddress('vkGetPipelineCacheData'); vkMergePipelineCaches := vkGetProcAddress('vkMergePipelineCaches'); vkCmdEndQuery := vkGetProcAddress('vkCmdEndQuery'); vkCmdResetQueryPool := vkGetProcAddress('vkCmdResetQueryPool'); vkWaitForFences := vkGetProcAddress('vkWaitForFences'); vkBindBufferMemory := vkGetProcAddress('vkBindBufferMemory'); vkBindImageMemory := vkGetProcAddress('vkBindImageMemory'); vkCmdBindVertexBuffers := vkGetProcAddress('vkCmdBindVertexBuffers'); vkCmdDispatchIndirect := vkGetProcAddress('vkCmdDispatchIndirect'); vkCmdDrawIndexedIndirect := vkGetProcAddress('vkCmdDrawIndexedIndirect'); vkCmdDrawIndirect := vkGetProcAddress('vkCmdDrawIndirect'); vkCmdFillBuffer := vkGetProcAddress('vkCmdFillBuffer'); vkCmdUpdateBuffer := vkGetProcAddress('vkCmdUpdateBuffer'); vkGetDeviceMemoryCommitment := vkGetProcAddress('vkGetDeviceMemoryCommitment'); vkResetCommandBuffer := vkGetProcAddress('vkResetCommandBuffer'); vkResetCommandPool := vkGetProcAddress('vkResetCommandPool'); vkResetDescriptorPool := vkGetProcAddress('vkResetDescriptorPool'); vkMapMemory := vkGetProcAddress('vkMapMemory'); vkCmdResetEvent := vkGetProcAddress('vkCmdResetEvent'); vkCmdSetEvent := vkGetProcAddress('vkCmdSetEvent'); vkCmdBeginQuery := vkGetProcAddress('vkCmdBeginQuery'); vkCmdCopyQueryPoolResults := vkGetProcAddress('vkCmdCopyQueryPoolResults'); vkGetQueryPoolResults := vkGetProcAddress('vkGetQueryPoolResults'); vkCmdPushConstants := vkGetProcAddress('vkCmdPushConstants'); vkCmdSetStencilCompareMask := vkGetProcAddress('vkCmdSetStencilCompareMask'); vkCmdSetStencilReference := vkGetProcAddress('vkCmdSetStencilReference'); vkCmdSetStencilWriteMask := vkGetProcAddress('vkCmdSetStencilWriteMask'); vkCmdBindPipeline := vkGetProcAddress('vkCmdBindPipeline'); vkCmdBindDescriptorSets := vkGetProcAddress('vkCmdBindDescriptorSets'); vkCmdSetViewport := vkGetProcAddress('vkCmdSetViewport'); vkEnumerateDeviceExtensionProperties := vkGetProcAddress('vkEnumerateDeviceExtensionProperties'); vkEnumerateInstanceExtensionProperties := vkGetProcAddress('vkEnumerateInstanceExtensionProperties'); vkGetRenderAreaGranularity := vkGetProcAddress('vkGetRenderAreaGranularity'); vkEnumerateDeviceLayerProperties := vkGetProcAddress('vkEnumerateDeviceLayerProperties'); vkEnumerateInstanceLayerProperties := vkGetProcAddress('vkEnumerateInstanceLayerProperties'); vkCmdBindIndexBuffer := vkGetProcAddress('vkCmdBindIndexBuffer'); vkGetPhysicalDeviceFeatures := vkGetProcAddress('vkGetPhysicalDeviceFeatures'); vkCmdCopyBuffer := vkGetProcAddress('vkCmdCopyBuffer'); vkGetBufferMemoryRequirements := vkGetProcAddress('vkGetBufferMemoryRequirements'); vkGetImageMemoryRequirements := vkGetProcAddress('vkGetImageMemoryRequirements'); vkGetPhysicalDeviceFormatProperties := vkGetProcAddress('vkGetPhysicalDeviceFormatProperties'); vkGetImageSubresourceLayout := vkGetProcAddress('vkGetImageSubresourceLayout'); vkCmdClearColorImage := vkGetProcAddress('vkCmdClearColorImage'); vkCmdClearDepthStencilImage := vkGetProcAddress('vkCmdClearDepthStencilImage'); vkAllocateCommandBuffers := vkGetProcAddress('vkAllocateCommandBuffers'); vkAllocateDescriptorSets := vkGetProcAddress('vkAllocateDescriptorSets'); vkCmdSetScissor := vkGetProcAddress('vkCmdSetScissor'); vkGetPhysicalDeviceQueueFamilyProperties := vkGetProcAddress('vkGetPhysicalDeviceQueueFamilyProperties'); vkGetPhysicalDeviceImageFormatProperties := vkGetProcAddress('vkGetPhysicalDeviceImageFormatProperties'); vkCmdCopyImage := vkGetProcAddress('vkCmdCopyImage'); vkCreateBuffer := vkGetProcAddress('vkCreateBuffer'); vkCreateBufferView := vkGetProcAddress('vkCreateBufferView'); vkCreateCommandPool := vkGetProcAddress('vkCreateCommandPool'); vkDestroyBuffer := vkGetProcAddress('vkDestroyBuffer'); vkDestroyBufferView := vkGetProcAddress('vkDestroyBufferView'); vkDestroyCommandPool := vkGetProcAddress('vkDestroyCommandPool'); vkCmdCopyBufferToImage := vkGetProcAddress('vkCmdCopyBufferToImage'); vkCmdBlitImage := vkGetProcAddress('vkCmdBlitImage'); vkQueueBindSparse := vkGetProcAddress('vkQueueBindSparse'); vkCmdCopyImageToBuffer := vkGetProcAddress('vkCmdCopyImageToBuffer'); vkCmdResolveImage := vkGetProcAddress('vkCmdResolveImage'); vkGetPhysicalDeviceMemoryProperties := vkGetProcAddress('vkGetPhysicalDeviceMemoryProperties'); vkCreateDescriptorPool := vkGetProcAddress('vkCreateDescriptorPool'); vkCreateDevice := vkGetProcAddress('vkCreateDevice'); vkCreateDescriptorSetLayout := vkGetProcAddress('vkCreateDescriptorSetLayout'); vkGetImageSparseMemoryRequirements := vkGetProcAddress('vkGetImageSparseMemoryRequirements'); vkDestroyDescriptorPool := vkGetProcAddress('vkDestroyDescriptorPool'); vkDestroyDescriptorSetLayout := vkGetProcAddress('vkDestroyDescriptorSetLayout'); vkDestroyDevice := vkGetProcAddress('vkDestroyDevice'); vkDestroyEvent := vkGetProcAddress('vkDestroyEvent'); vkDestroyFence := vkGetProcAddress('vkDestroyFence'); vkDestroyFramebuffer := vkGetProcAddress('vkDestroyFramebuffer'); vkDestroyImage := vkGetProcAddress('vkDestroyImage'); vkDestroyImageView := vkGetProcAddress('vkDestroyImageView'); vkDestroyInstance := vkGetProcAddress('vkDestroyInstance'); vkDestroyPipeline := vkGetProcAddress('vkDestroyPipeline'); vkDestroyPipelineCache := vkGetProcAddress('vkDestroyPipelineCache'); vkDestroyPipelineLayout := vkGetProcAddress('vkDestroyPipelineLayout'); vkGetPhysicalDeviceProperties := vkGetProcAddress('vkGetPhysicalDeviceProperties'); vkDestroyQueryPool := vkGetProcAddress('vkDestroyQueryPool'); vkDestroyRenderPass := vkGetProcAddress('vkDestroyRenderPass'); vkDestroySampler := vkGetProcAddress('vkDestroySampler'); vkDestroySemaphore := vkGetProcAddress('vkDestroySemaphore'); vkDestroyShaderModule := vkGetProcAddress('vkDestroyShaderModule'); vkFreeMemory := vkGetProcAddress('vkFreeMemory'); vkCmdClearAttachments := vkGetProcAddress('vkCmdClearAttachments'); vkBeginCommandBuffer := vkGetProcAddress('vkBeginCommandBuffer'); vkCmdNextSubpass := vkGetProcAddress('vkCmdNextSubpass'); vkCmdWriteTimestamp := vkGetProcAddress('vkCmdWriteTimestamp'); vkGetPhysicalDeviceSparseImageFormatProperties := vkGetProcAddress('vkGetPhysicalDeviceSparseImageFormatProperties'); vkFlushMappedMemoryRanges := vkGetProcAddress('vkFlushMappedMemoryRanges'); vkInvalidateMappedMemoryRanges := vkGetProcAddress('vkInvalidateMappedMemoryRanges'); vkAllocateMemory := vkGetProcAddress('vkAllocateMemory'); vkCreateEvent := vkGetProcAddress('vkCreateEvent'); vkCreateFence := vkGetProcAddress('vkCreateFence'); vkCreateFramebuffer := vkGetProcAddress('vkCreateFramebuffer'); vkCreateImage := vkGetProcAddress('vkCreateImage'); vkCreatePipelineCache := vkGetProcAddress('vkCreatePipelineCache'); vkQueueSubmit := vkGetProcAddress('vkQueueSubmit'); vkCreateQueryPool := vkGetProcAddress('vkCreateQueryPool'); vkCreateSampler := vkGetProcAddress('vkCreateSampler'); vkCreateSemaphore := vkGetProcAddress('vkCreateSemaphore'); vkCreateShaderModule := vkGetProcAddress('vkCreateShaderModule'); vkCmdPipelineBarrier := vkGetProcAddress('vkCmdPipelineBarrier'); vkCmdWaitEvents := vkGetProcAddress('vkCmdWaitEvents'); vkCreatePipelineLayout := vkGetProcAddress('vkCreatePipelineLayout'); vkCreateImageView := vkGetProcAddress('vkCreateImageView'); vkCreateInstance := vkGetProcAddress('vkCreateInstance'); vkUpdateDescriptorSets := vkGetProcAddress('vkUpdateDescriptorSets'); vkCmdBeginRenderPass := vkGetProcAddress('vkCmdBeginRenderPass'); vkCreateRenderPass := vkGetProcAddress('vkCreateRenderPass'); vkCreateGraphicsPipelines := vkGetProcAddress('vkCreateGraphicsPipelines'); vkCreateComputePipelines := vkGetProcAddress('vkCreateComputePipelines'); end; procedure FinalizeVulkan; begin vkFreeLibrary(vkLibHandle); end; initialization finalization FinalizeVulkan; end.