From 97425e0bb206c295e3ae96087380e6f990b75def Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Mon, 22 Feb 2016 19:31:57 +0100 Subject: [PATCH] * [generator] fixed some small bugs in and generated first Vulkan.pas :) --- data/vulkan.tpl | 137 ++ projects/Vulkan.pas | 2832 ++++++++++++++++++++++++ projects/generator/HeaderGenerator.pas | 813 ++++++- projects/generator/generator.lpi | 9 +- projects/generator/generator.lpr | 6 +- projects/generator/generator.lps | 199 +- 6 files changed, 3849 insertions(+), 147 deletions(-) create mode 100644 projects/Vulkan.pas diff --git a/data/vulkan.tpl b/data/vulkan.tpl index e69de29..0edbd78 100644 --- a/data/vulkan.tpl +++ b/data/vulkan.tpl @@ -0,0 +1,137 @@ +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 + +{%INTERFACE%} + +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; + + {%IMPLEMENTATION%} +end; + +procedure FinalizeVulkan; +begin + vkFreeLibrary(vkLibHandle); +end; + +initialization + +finalization + FinalizeVulkan; + +end. diff --git a/projects/Vulkan.pas b/projects/Vulkan.pas new file mode 100644 index 0000000..37669f6 --- /dev/null +++ b/projects/Vulkan.pas @@ -0,0 +1,2832 @@ +{ ============================================================================ +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. diff --git a/projects/generator/HeaderGenerator.pas b/projects/generator/HeaderGenerator.pas index 73f2a0d..76a7fac 100644 --- a/projects/generator/HeaderGenerator.pas +++ b/projects/generator/HeaderGenerator.pas @@ -15,39 +15,62 @@ type otUnknown, otType, otHandle, + otEnum, + otConst, otFuncPtr, otStruct, - otEnum, otCommand); TvkObjectTypes = set of TvkObjectType; TvkObject = class; TvkObjectList = class(specialize TFPGObjectList) public + function IndexOfObj(const aName: DOMstring; const aTypes: TvkObjectTypes): Integer; function FindObj(const aName: DOMstring; const aTypes: TvkObjectTypes; out aObject): Boolean; procedure MarkObj(const aName: DOMstring; const aTypes: TvkObjectTypes; const aMark: Integer); + function GetPascalName(const aName: DOMString; const aPointer: Integer; const aArrSize: WideString = ''): WideString; end; //////////////////////////////////////////////////////////////////////////////////////////// TvkObject = class(TObject) private fType: TvkObjectType; - fMark: Integer; fName: DOMString; fComment: DOMString; + fMark: Integer; + fConstGenerated: Boolean; + fTypeGenerated: Boolean; + fPtrGenerated: Boolean; + fVarGenerated: Boolean; + fImplGenerated: Boolean; fList: TvkObjectList; private procedure SetMark(aValue: Integer); protected + function GetDependencyOrder: Integer; virtual; procedure DoMark(const aMark: Integer); virtual; + procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); virtual; public - property Mark: Integer read fMark write SetMark; - property Name: DOMString read fName write fName; - property Comment: DOMString read fComment write fComment; - property VkType: TvkObjectType read fType; - property List: TvkObjectList read fList write fList; + property VkType: TvkObjectType read fType; + property Name: DOMString read fName write fName; + property Comment: DOMString read fComment write fComment; + property Mark: Integer read fMark write SetMark; + property ConstGenerated: Boolean read fConstGenerated; + property TypeGenerated: Boolean read fTypeGenerated; + property PtrGenerated: Boolean read fPtrGenerated; + property VarGenerated: Boolean read fVarGenerated; + property ImplGenerated: Boolean read fImplGenerated; + property DependencyOrder: Integer read GetDependencyOrder; + property List: TvkObjectList read fList write fList; procedure AddCommentFromXml(xml: TDOMNode); + function GetPascalName(const aPointer: Integer; const aArrSize: WideString): WideString; + + function GenerateConst(const aCode: TStrings): Boolean; virtual; + function GenerateType(const aCode: TStrings): Boolean; virtual; + function GeneratePtr(const aCode: TStrings): Boolean; virtual; + function GenerateVar(const aCode: TStrings): Boolean; virtual; + function GenerateImpl(const aCode: TStrings): Boolean; virtual; constructor Create(const aType: TvkObjectType); public @@ -58,10 +81,17 @@ type TvkTypeSimple = class(TvkObject) private fParent: DOMString; + fAlias: DOMString; protected + function GetDependencyOrder: Integer; override; procedure DoMark(const aMark: Integer); override; + procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); override; public property Parent: DOMString read fParent write fParent; + property Alias: DOMString read fAlias write fAlias; + + function GenerateType(const aCode: TStrings): Boolean; override; + function GeneratePtr(const aCode: TStrings): Boolean; override; public class function CreateFromXml(const xml: TDOMNode): THeaderGenerator.TvkTypeSimple; end; @@ -82,7 +112,7 @@ type TArgument = class(TObject) Typ: DOMString; Name: DOMString; - IsPointer: Boolean; + IsPointer: Integer; IsConst: Boolean; end; TArgumentList = specialize TFPGObjectList; @@ -90,7 +120,11 @@ type fReturnValue: TArgument; fArguments: TArgumentList; protected + function GetDependencyOrder: Integer; override; procedure DoMark(const aMark: Integer); override; + procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); override; + + procedure GenerateFunctionPtr(const aCode: TStrings); public property ReturnValue: TArgument read fReturnValue; property Arguments: TArgumentList read fArguments; @@ -101,12 +135,18 @@ type //////////////////////////////////////////////////////////////////////////////////////////// TvkTypeFunctionPtr = class(TvkTypeFunction) + public + function GenerateType(const aCode: TStrings): Boolean; override; public class function CreateFromXml(const xml: TDOMNode): THeaderGenerator.TvkTypeFunctionPtr; end; //////////////////////////////////////////////////////////////////////////////////////////// TvkCommand = class(TvkTypeFunction) + public + function GenerateType(const aCode: TStrings): Boolean; override; + function GenerateVar(const aCode: TStrings): Boolean; override; + function GenerateImpl(const aCode: TStrings): Boolean; override; public class function CreateFromXml(const xml: TDOMNode): THeaderGenerator.TvkCommand; end; @@ -117,8 +157,8 @@ type TMember = class(TObject) Typ: DOMString; Name: DOMString; - ArrSize: Integer; - IsPointer: Boolean; + ArrSize: DOMString; + IsPointer: Integer; IsConst: Boolean; end; TMemberList = specialize TFPGObjectList; @@ -126,11 +166,15 @@ type fIsUnion: Boolean; fMember: TMemberList; protected + function GetDependencyOrder: Integer; override; procedure DoMark(const aMark: Integer); override; + procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); override; public property Member: TMemberList read fMember; property IsUnion: Boolean read fIsUnion write fIsUnion; + function GenerateType(const aCode: TStrings): Boolean; override; + constructor Create(const aType: TvkObjectType); destructor Destroy; override; public @@ -148,9 +192,14 @@ type TValueList = specialize TFPGObjectList; private fValues: TValueList; + protected + procedure GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); override; public property Values: TValueList read fValues; + function GenerateConst(const aCode: TStrings): Boolean; override; + function GenerateType(const aCode: TStrings): Boolean; override; + constructor Create(const aType: TvkObjectType); destructor Destroy; override; public @@ -162,10 +211,14 @@ type private fDocument: TXMLDocument; - fComment: DOMString; fObjects: TvkObjectList; + fOutputFile: String; + fTemplateFile: String; public + property OutputFile: String read fOutputFile write fOutputFile; + property TemplateFile: String read fTemplateFile write fTemplateFile; + procedure ReadFile(const aFilename: String); procedure ReadFile(const aStream: TStream); @@ -178,7 +231,7 @@ type implementation uses - XMLRead, RegExpr; + Math, XMLRead, RegExpr; type XmlException = class(Exception) @@ -187,6 +240,70 @@ type constructor Create(const aMsg: WideString; const aXml: TDOMNode); end; +const + COMMENT_HEAD = '{ ============================================================================' + sLineBreak; + COMMENT_BREAK = sLineBreak + sLineBreak + '==============================================================================' + sLineBreak + sLineBreak; + COMMENT_TAIL = sLineBreak + '============================================================================ }'; + COMMENT_CONTENT = + 'This file is autogenerated from vk.xml' + sLineBreak + + '' + sLineBreak + + 'You may retrieve the latest version of this file at the Delphi OpenGL' + sLineBreak + + 'Community home page, located at http://www.delphigl.com/' + sLineBreak + + '' + sLineBreak + + 'The contents of this file are used with permission, subject to' + sLineBreak + + 'the Mozilla Public License Version 1.1 (the "License"); you may' + sLineBreak + + 'not use this file except in compliance with the License. You may' + sLineBreak + + 'obtain a copy of the License at' + sLineBreak + + 'http://www.mozilla.org/MPL/MPL-1.1.html' + sLineBreak + + '' + sLineBreak + + 'Software distributed under the License is distributed on an' + sLineBreak + + '"AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or' + sLineBreak + + 'implied. See the License for the specific language governing' + sLineBreak + + 'rights and limitations under the License.' + sLineBreak; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function PointerCount(const aStr: AnsiString): Integer; +var i: Integer; +begin + result := 0; + i := Length(aStr); + while (i > 0) do begin + if (aStr[i] = '*') then + inc(result); + dec(i); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function PrepareName(const aName, aType: WideString): WideString; +var rx: TRegExpr; +begin + result := aName; + if (result = 'type') then begin + rx := TRegExpr.Create('^(T|P)?(Vk)?(.)'); + try + if rx.Exec(String(aType)) + then result := WideString(LowerCase(rx.Match[3]) + 'Type') + else result := 'mType'; + finally + FreeAndNil(rx); + end; + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function CompareVkObjDependency(const aItem1, aItem2: THeaderGenerator.TvkObject): Integer; +var + w1, w2: WideString; +begin + result := (aItem1.DependencyOrder - aItem2.DependencyOrder); + if (result = 0) then begin + w1 := aItem1.Name; + w2 := aItem2.Name; + result := strcomp(PWideChar(w1), PWideChar(w2)); + end; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function FormatType(const aType: THeaderGenerator.TvkObjectType): WideString; begin @@ -196,6 +313,7 @@ begin otFuncPtr: result := 'FUNCPTR'; otStruct: result := 'STRUCT'; otEnum: result := 'ENUM'; + otConst: result := 'CONSTANT'; otCommand: result := 'COMMAND'; else result := ''; @@ -266,27 +384,33 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkObjectList//////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function THeaderGenerator.TvkObjectList.FindObj(const aName: DOMstring; const aTypes: TvkObjectTypes; out aObject): Boolean; -var - o: TvkObject; +function THeaderGenerator.TvkObjectList.IndexOfObj(const aName: DOMstring; const aTypes: TvkObjectTypes): Integer; +var o: TvkObject; begin if (aName = '') then raise Exception.Create('empty name'); - result := true; - TvkObject(aObject) := nil; - for o in self do begin - if (o.VkType in aTypes) and (o.Name = aName) then begin - TvkObject(aObject) := o; + for result := 0 to Count-1 do begin + o := Get(result); + if (o.VkType in aTypes) and (o.Name = aName) then exit; - end; end; - result := false; + result := -1; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObjectList.FindObj(const aName: DOMstring; const aTypes: TvkObjectTypes; out aObject): Boolean; +var i: Integer; +begin + i := IndexOfObj(aName, aTypes); + result := (i >= 0); + if result + then TvkObject(aObject) := Get(i) + else TvkObject(aObject) := nil; end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure THeaderGenerator.TvkObjectList.MarkObj(const aName: DOMstring; const aTypes: TvkObjectTypes; - const aMark: Integer); +procedure THeaderGenerator.TvkObjectList.MarkObj(const aName: DOMstring; const aTypes: TvkObjectTypes; const aMark: Integer); var o: TvkObject; begin if FindObj(aName, aTypes, o) @@ -294,6 +418,16 @@ begin else WriteResolveWarning(aName); end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObjectList.GetPascalName(const aName: DOMString; const aPointer: Integer; + const aArrSize: WideString): WideString; +var o: TvkObject; +begin + if FindObj(aName, VK_OBJECT_TYPES, o) + then result := o.GetPascalName(aPointer, aArrSize) + else result := aName; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkObject//////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -305,12 +439,39 @@ begin DoMark(fMark); end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GetDependencyOrder: Integer; +begin + result := 0; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkObject.DoMark(const aMark: Integer); begin WriteLn(Format(' %-10s%-50s marked for generation', [FormatType(fType), fName])); end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkObject.GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); +var + i: Integer; +begin + if (aName = '') then begin + aName := fName; + if (aName = 'void') then + aName := 'VkVoid'; + for i := 0 to aPointer-1 do + aName := 'P' + aName; + end; + if (aName = 'VkVoid') then + raise Exception.Create('void can not be used as type'); + if (aArrSize <> '') then begin + if TryStrToInt(String(aArrSize), i) + then aName := WideString(Format('array[0..%d] of %s', [i, aName])) + else aName := WideString(Format('array[0..%s-1] of %s', [aArrSize, aName])); + end; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkObject.AddCommentFromXml(xml: TDOMNode); begin @@ -319,6 +480,63 @@ begin fComment := xml.TextContent; end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GetPascalName(const aPointer: Integer; const aArrSize: WideString): WideString; +begin + result := ''; + GenPascalName(result, aPointer, aArrSize); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GenerateConst(const aCode: TStrings): Boolean; +begin + result := not fConstGenerated; + if not fConstGenerated then begin + fConstGenerated := true; + WriteLn(Format(' %-10s%-50s constants generated', [FormatType(fType), fName])); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GenerateType(const aCode: TStrings): Boolean; +begin + result := not fTypeGenerated; + if not fTypeGenerated then begin + fTypeGenerated := true; + WriteLn(Format(' %-10s%-50s type generated', [FormatType(fType), fName])); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GeneratePtr(const aCode: TStrings): Boolean; +begin + result := not fPtrGenerated; + if not fPtrGenerated then begin + fPtrGenerated := true; + WriteLn(Format(' %-10s%-50s pointer type generated', [FormatType(fType), fName])); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GenerateVar(const aCode: TStrings): Boolean; +begin + result := not fVarGenerated; + if not fVarGenerated then begin + fVarGenerated := true; + WriteLn(Format(' %-10s%-50s variables generated', [FormatType(fType), fName])); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkObject.GenerateImpl(const aCode: TStrings): Boolean; +begin + result := not fImplGenerated; + if not fImplGenerated then begin + fImplGenerated := true; + WriteLn(Format(' %-10s%-50s implementation generated', [FormatType(fType), fName])); + end; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor THeaderGenerator.TvkObject.Create(const aType: TvkObjectType); begin @@ -352,12 +570,54 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkTypeSimple//////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeSimple.GetDependencyOrder: Integer; +begin + result := inherited GetDependencyOrder; + if Assigned(List) and (fParent <> '') then + result := max(result, List.IndexOfObj(fParent, VK_OBJECT_TYPES) + 1); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkTypeSimple.DoMark(const aMark: Integer); begin inherited DoMark(aMark); if (fParent <> '') and Assigned(fList) then - fList.MarkObj(fParent, VK_OBJECT_TYPES, aMark); + fList.MarkObj(fParent, VK_OBJECT_TYPES, aMark); + if (fAlias <> '') and Assigned(fList) then + fList.MarkObj(fAlias, VK_OBJECT_TYPES, aMark); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkTypeSimple.GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); +var i: Integer; +begin + if (fAlias <> '') + then aName := fAlias + else aName := fName; + if (aName = 'void') then + aName := 'VkVoid'; + for i := 0 to aPointer-1 do + aName := 'P' + aName; + inherited GenPascalName(aName, aPointer, aArrSize); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeSimple.GenerateType(const aCode: TStrings): Boolean; +begin + result := inherited GenerateType(aCode); + if result and (fParent <> '') and Assigned(List) then + aCode.Add(Format(' %-62s = %s;', [ fName, List.GetPascalName(fParent, 0) ])); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeSimple.GeneratePtr(const aCode: TStrings): Boolean; +begin + result := inherited GeneratePtr(aCode); + if result and (fParent <> '') and Assigned(List) then begin + aCode.Add(Format(' P%-61s = ^%0:s;', [ fName ])); + aCode.Add(Format(' PP%-60s = ^P%0:s;', [ fName ])); + end; end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -389,6 +649,17 @@ begin end; end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeFunction.GetDependencyOrder: Integer; +var a: TArgument; +begin + result := inherited GetDependencyOrder; + if not Assigned(List) then + exit; + for a in fArguments do + result := max(result, List.IndexOfObj(a.Typ, VK_OBJECT_TYPES)); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkTypeFunction.DoMark(const aMark: Integer); var a: TArgument; @@ -402,7 +673,51 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//THeaderGenerator.TvkTypeFunction/////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkTypeFunction.GenPascalName(var aName: WideString; const aPointer: Integer; + const aArrSize: WideString); +var rx: TRegExpr; +begin + if (aPointer > 0) then + Exception.Create('function pointer can not be used as pointer type'); + if (aArrSize <> '') then + Exception.Create('function pointer can not be used as array type'); + + rx := TRegExpr.Create('PFN_([-_A-Za-z0-9]+)'); + try + if rx.Exec(String(fName)) + then aName := 'T' + WideString(rx.Match[1]) + else aName := 'T' + fName; + finally + FreeAndNil(rx); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkTypeFunction.GenerateFunctionPtr(const aCode: TStrings); +var + s: WideString; + i: Integer; + a: TArgument; +begin + s := WideString(Format(' %-50s', [ GetPascalName(0, '') ])); + if (ReturnValue.Typ = 'void') + then s := s + ' = procedure(' + else s := s + ' = function ('; + for i := 0 to fArguments.Count-1 do begin + a := fArguments[i]; + if a.IsConst then + s := s + 'const '; + s := s + PrepareName(a.Name, a.Typ) + ': ' + List.GetPascalName(a.Typ, a.IsPointer); + if (i < fArguments.Count-1) then + s := s + '; '; + end; + s := s + ')'; + if (ReturnValue.Typ <> 'void') then + s := s + ': ' + List.GetPascalName(ReturnValue.Typ, ReturnValue.IsPointer); + s := s + '; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};'; + aCode.Add(String(s)); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor THeaderGenerator.TvkTypeFunction.Create(const aType: TvkObjectType); begin @@ -421,6 +736,15 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkTypeFunctionPtr/////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeFunctionPtr.GenerateType(const aCode: TStrings): Boolean; + +begin + result := inherited GenerateType(aCode); + if result and Assigned(List) then + GenerateFunctionPtr(aCode); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class function THeaderGenerator.TvkTypeFunctionPtr.CreateFromXml(const xml: TDOMNode): THeaderGenerator.TvkTypeFunctionPtr; var @@ -439,14 +763,14 @@ begin if not Assigned(p) then raise XmlException.Create(xml.NodeName + ' witout return type', xml); - rx := TRegExpr.Create('typedef\s+((const)?)\s*([-_A-Za-z0-9\s]+?)\s*(\*?)\s*\('); + rx := TRegExpr.Create('typedef\s+((const)?)\s*([-_A-Za-z0-9\s]+?)\s*((\*\s*(const)?\s*)*)\s*\('); try if not rx.Exec(String(p.TextContent)) then raise XmlException.Create('unable to parse return type of function pointer', xml); result.ReturnValue.IsConst := (Trim(rx.Match[1]) = 'const'); result.ReturnValue.Typ := WideString(Trim(rx.Match[3])); - result.ReturnValue.IsPointer := (Trim(rx.Match[4]) = '*'); + result.ReturnValue.IsPointer := PointerCount(Trim(rx.Match[4])); x := xml.FirstChild; while Assigned(x) do begin @@ -463,12 +787,12 @@ begin p := x.NextSibling; if not Assigned(p) then raise XmlException.Create('unable to parse function pointer arguments', xml); - rx.Expression := '(\*?)\s*([-_A-Za-z0-9]+)'; + rx.Expression := '((\*\s*(const)?\s*)*)\s*([-_A-Za-z0-9]+)'; if not rx.Exec(String(p.TextContent)) then raise XmlException.Create('unable to parse function pointer arguments', xml); - a.IsPointer := (rx.Match[1] = '*'); - a.Name := WideString(Trim(rx.Match[2])); + a.IsPointer := PointerCount((rx.Match[1])); + a.Name := WideString(Trim(rx.Match[4])); result.Arguments.Add(a); except FreeAndNil(a) @@ -487,6 +811,30 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkCommand/////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkCommand.GenerateType(const aCode: TStrings): Boolean; +begin + result := inherited GenerateType(aCode); + if result and Assigned(List) then + GenerateFunctionPtr(aCode); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkCommand.GenerateVar(const aCode: TStrings): Boolean; +begin + result := inherited GenerateVar(aCode); + if result then + aCode.Add(Format(' %-50s %s = nil;', [ fName + ':', GetPascalName(0, '') ])); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkCommand.GenerateImpl(const aCode: TStrings): Boolean; +begin + result := inherited GenerateImpl(aCode); + if result then + aCode.Add(Format(' %-50s := vkGetProcAddress(''%0:s'');', [ fName ])); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class function THeaderGenerator.TvkCommand.CreateFromXml(const xml: TDOMNode): THeaderGenerator.TvkCommand; @@ -500,9 +848,11 @@ class function THeaderGenerator.TvkCommand.CreateFromXml(const xml: TDOMNode): T var p: TDOMNode; a: TArgument; + rx: TRegExpr; begin a := TArgument.Create; - try + rx := TRegExpr.Create; + try try p := x.FindNode('name'); if not Assigned(p) then raise XmlException.Create('unable to parse command; param without name', xml); @@ -513,8 +863,14 @@ class function THeaderGenerator.TvkCommand.CreateFromXml(const xml: TDOMNode): T raise XmlException.Create('unable to parse command; param without type', xml); a.Typ := p.TextContent; a.IsConst := Assigned(p.PreviousSibling) and (Trim(p.PreviousSibling.TextContent) = 'const'); - a.IsPointer := Assigned(p.NextSibling) and (Trim(p.NextSibling.TextContent) = '*'); + + rx.Expression := '((\*\s*(const)?\s*)*)'; + if Assigned(p.NextSibling) and rx.Exec(String(p.NextSibling.TextContent)) then + a.IsPointer := PointerCount(rx.Match[0]); result.Arguments.Add(a); + finally + FreeAndNil(rx); + end; except FreeAndNil(a); raise; @@ -540,6 +896,20 @@ begin end; end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//THeaderGenerator.TvkTypeStruct//////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeStruct.GetDependencyOrder: Integer; +var + m: TMember; +begin + result := inherited GetDependencyOrder; + if not Assigned(List) then + exit; + for m in fMember do + result := max(result, List.IndexOfObj(m.Typ, VK_OBJECT_TYPES) + 1); +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.TvkTypeStruct.DoMark(const aMark: Integer); var m: TMember; @@ -551,6 +921,51 @@ begin end; end; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkTypeStruct.GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); +var i: Integer; +begin + if (aPointer > 0) then begin + aName := fName; + for i := 0 to aPointer-1 do + aName := 'P' + aName; + end else + aName := 'T' + fName; + inherited GenPascalName(aName, aPointer, aArrSize); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeStruct.GenerateType(const aCode: TStrings): Boolean; +var + prefix, postfix: String; + i, indent: Integer; + m: TMember; +begin + result := inherited GenerateType(aCode); + result := inherited GeneratePtr(aCode) or result; + if result and Assigned(List) then begin + postfix := ';'; + indent := 50; + aCode.Add(' T%s = record', [ fName ]); + if IsUnion then begin + aCode.Add(' case Integer of'); + postfix := ');'; + indent := 42; + end; + for i := 0 to fMember.Count-1 do begin + m := fMember[i]; + if IsUnion + then prefix := Format(' %.3d: (', [ i ]) + else prefix := ' '; + aCode.Add(Format('%s%-*s%s%s', [ prefix, indent, PrepareName(m.Name, m.Typ) + ': ', List.GetPascalName(m.Typ, m.IsPointer, m.ArrSize), postfix ])); + end; + aCode.Add(' end;'); + aCode.Add(' P%s = ^T%0:s;', [ fName ]); + aCode.Add(' PP%s = ^P%0:s;', [ fName ]); + aCode.Add(''); + end; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkTypeStruct//////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -583,23 +998,24 @@ begin while Assigned(x) do begin if (x.NodeName = 'member') then begin m := TMember.Create; - try + rx := TRegExpr.Create(''); + try try // read name p := x.FindNode('name'); if not Assigned(p) then raise XmlException.Create('struct member without name', xml); m.Name := p.TextContent; - if Assigned(p.NextSibling) then - m.Name := m.Name + p.NextSibling.TextContent; + p := p.NextSibling; + while Assigned(p) do begin + m.Name := m.Name + p.TextContent; + p := p.NextSibling; + end; m.Name := Trim(m.Name); - rx := TRegExpr.Create('([-_A-Za-z0-9]+)\s*\[\s*([0-9]+)\s*\]'); - try - if rx.Exec(String(m.Name)) then begin - m.Name := WideString(rx.Match[1]); - m.ArrSize := StrToInt(rx.Match[2]); - end; - finally - FreeAndNil(rx); + + rx.Expression := '([-_A-Za-z0-9]+)\s*\[\s*([-_A-Za-z0-9]+)\s*\]'; + if rx.Exec(String(m.Name)) then begin + m.Name := WideString(rx.Match[1]); + m.ArrSize := WideString(rx.Match[2]); end; // read type @@ -608,8 +1024,13 @@ begin raise XmlException.Create('struct member without type', xml); m.Typ := p.TextContent; m.IsConst := Assigned(p.PreviousSibling) and (Trim(p.PreviousSibling.TextContent) = 'const'); - m.IsPointer := Assigned(p.NextSibling) and (Trim(p.NextSibling.TextContent) = '*'); + rx.Expression := '((\*\s*(const)?\s*)*)'; + if Assigned(p.NextSibling) and rx.Exec(String(p.NextSibling.TextContent)) then + m.IsPointer := PointerCount(rx.Match[0]); result.Member.Add(m); + finally + FreeAndNil(rx); + end; except FreeAndNil(m); end; @@ -624,6 +1045,66 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //THeaderGenerator.TvkTypeEnum////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure THeaderGenerator.TvkTypeEnum.GenPascalName(var aName: WideString; const aPointer: Integer; const aArrSize: WideString); +var i: Integer; +begin + if (fName = '') then + raise Exception.Create('enum with empty name'); + if (aPointer > 0) then begin + aName := fName; + for i := 0 to aPointer-1 do + aName := 'P' + aName; + end else + aName := 'T' + fName; + inherited GenPascalName(aName, aPointer, aArrSize); +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeEnum.GenerateConst(const aCode: TStrings): Boolean; +var + value: String; + i: Integer; + v: TValue; +begin + result := inherited GenerateConst(aCode); + if result and (VkType = otConst) then begin + for i := 0 to fValues.Count-1 do begin + v := fValues[i]; + if v.IsBit + then value := Format('(1 shl %s)', [ IntToStr(v.Value) ]) + else value := v.Value; + aCode.Add(Format(' %-62s = %s;', [ v.Name, value ])); + end; + aCode.Add(''); + end; +end; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function THeaderGenerator.TvkTypeEnum.GenerateType(const aCode: TStrings): Boolean; +var + value: String; + i: Integer; + v: TValue; +begin + result := inherited GenerateType(aCode); + if result and (VkType = otEnum) then begin + aCode.Add(Format(' T%s = (', [ fName ])); + for i := 0 to fValues.Count-1 do begin + v := fValues[i]; + if v.IsBit + then value := Format('(1 shl %s)', [ IntToStr(v.Value) ]) + else value := v.Value; + aCode.Add(Format(' %-60s = %s', [ v.Name, value ])); + if (i < fValues.Count-1) then + aCode[aCode.Count-1] := aCode[aCode.Count-1] + ','; + end; + aCode.Add(' );'); + aCode.Add(Format(' P%s = ^T%0:s;', [ fName ])); + aCode.Add(''); + end; +end; + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// constructor THeaderGenerator.TvkTypeEnum.Create(const aType: TvkObjectType); begin @@ -654,9 +1135,13 @@ var try result := Unassigned; - rx.Expression := '^-?(0x)?([0-9A-Fa-f]+)$'; + rx.Expression := '^-?([0-9]+)$'; + if rx.Exec(s) then + result := StrToInt(rx.Match[0]); + + rx.Expression := '^0x([0-9A-Fa-f]+)$'; if rx.Exec(s) then - result := StrToInt(rx.Match[1] + rx.Match[2]); + result := '$' + rx.Match[1]; rx.Expression := '^([0-9\.]+)(f|d)?$'; if rx.Exec(s) then begin @@ -668,8 +1153,8 @@ var rx.Expression := '^\(~0U([L]*)\)$'; if rx.Exec(s) then begin if (rx.Match[2] = '') - then result := High(Cardinal) - else result := High(UInt64); + then result := '$' + IntToHex(High(UInt32), 2 * sizeof(UInt32)) + else result := '$' + IntToHex(High(UInt64), 2 * sizeof(UInt64)); end; if (result = Unassigned) then @@ -680,7 +1165,10 @@ var end; begin - result := TvkTypeEnum.Create(otEnum); + x := xml.Attributes.GetNamedItem('type'); + if Assigned(x) + then result := TvkTypeEnum.Create(otEnum) + else result := TvkTypeEnum.Create(otConst); try result.Name := GetNodeAttrib(xml, 'name'); x := xml.FirstChild; @@ -697,7 +1185,7 @@ begin p := x.Attributes.GetNamedItem('bitpos'); if not Assigned(p) then raise XmlException.Create('enum without value or bitpos', xml); - v.IsBit := false; + v.IsBit := true; v.Value := StrToValue(String(p.TextContent)); end; result.Values.Add(v); @@ -733,9 +1221,19 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.ReadFile(const aStream: TStream); +type + TGenPass = ( + gpConst, + gpType, + gpPointer, + gpVar, + gpImpl + ); + var xml: TDOMNode; CurrentMark: Integer; + tpl: TStringList; procedure AddObject(const aObj: TvkObject); begin @@ -743,6 +1241,8 @@ var fObjects.Add(aObj); aObj.List := fObjects; WriteLn(Format(' %-10s%s', [FormatType(aObj.VkType), aObj.Name])); + if (aObj.VkType = otConst) then + aObj.Mark := CurrentMark; end; end; @@ -757,6 +1257,85 @@ var end; end; + procedure GenerateType(const aCode: TStrings; const aType: TvkObjectType; const aPass: TGenPass); + var + o: TvkObject; + begin + for o in fObjects do begin + if (o.VkType = aType) and (o.Mark = CurrentMark) then begin + case aPass of + gpConst: o.GenerateConst(aCode); + gpType: o.GenerateType(aCode); + gpPointer: o.GeneratePtr(aCode); + gpVar: o.GenerateVar(aCode); + gpImpl: o.GenerateImpl(aCode); + end; + end; + end; + end; + + procedure InsertAt(const aPlaceholder: String; const aText: TStrings); + var i, j: Integer; + begin + for i := tpl.Count-1 downto 0 do begin + if (Pos(aPlaceholder, tpl[i]) > 0) then begin + for j := aText.Count-1 downto 0 do + tpl.Insert(i, aText[j]); + end; + end; + end; + + procedure InsertAt(const aPlaceholder: String; const aText: String); + var sl: TStringList; + begin + sl := TStringList.Create; + try + sl.Text := aText; + InsertAt(aPlaceholder, sl); + finally + FreeAndNil(sl); + end; + end; + + procedure GeneratePass(const aType: TvkObjectType; const aPass: TGenPass; const aPrefix, aPlaceholder: String); + var sl: TStringList; + begin + sl := TStringList.Create; + try + GenerateType(sl, aType, aPass); + if (sl.Count > 0) then begin + sl.Insert(0, aPrefix); + sl.Add(''); + end; + InsertAt(aPlaceholder, sl); + finally + FreeAndNil(sl); + end; + end; + + procedure Generate(const aTypes: TvkObjectTypes); + var t: TvkObjectType; + begin + for t in aTypes do begin + GeneratePass(t, gpConst, Format('const { %ss }', [ LowerCase(FormatType(t)) ]), '{%INTERFACE%}'); + GeneratePass(t, gpType, Format('type { %ss }', [ LowerCase(FormatType(t)) ]), '{%INTERFACE%}'); + GeneratePass(t, gpPointer, Format('type { %s pointers }', [ LowerCase(FormatType(t)) ]), '{%INTERFACE%}'); + GeneratePass(t, gpVar, Format('var { %s variables }', [ LowerCase(FormatType(t)) ]), '{%INTERFACE%}'); + GeneratePass(t, gpImpl, '', '{%IMPLEMENTATION%}'); + end; + end; + + procedure Generate(const aName: DOMString); + begin + fObjects.Sort(@CompareVkObjDependency); + InsertAt('{%INTERFACE%}', Format('{********************************* %s *********************************}', [ aName ])); + InsertAt('{%IMPLEMENTATION%}', Format('{********************************* %s *********************************}', [ aName ])); + Generate([ otConst ]); + Generate([ otType, otHandle, otEnum, otStruct, otFuncPtr ]); + Generate([ otCommand ]); + inc(CurrentMark); + end; + procedure EnableFeature(const xml: TDOMNode); var x: TDOMNode; @@ -772,64 +1351,122 @@ var x := x.NextSibling; end; + + if (xml.NodeName = 'feature') or (xml.NodeName = 'extension') then + Generate(GetNodeAttrib(xml, 'name')); + end; + + procedure RemoveLines(const aText: TStrings); + var + i: Integer; + b: Boolean; + rx: TRegExpr; + begin + i := 0; + rx := TRegExpr.Create('{%.*?%}'); + try + while (i < aText.Count) do begin + if (rx.Exec(aText[i])) then begin + aText.Delete(i); + continue; + end; + + if (Trim(aText[i]) = '') then begin + if b then begin + aText.Delete(i); + continue; + end else + b := true; + end else + b := false; + + inc(i); + end; + finally + FreeAndNil(rx); + end; end; begin Clear; ReadXMLFile(fDocument, aStream); - CurrentMark := 1; - WriteLn('read xml data'); - xml := fDocument.DocumentElement.FirstChild; - while Assigned(xml) do begin - if (xml.NodeName = 'types') or (xml.NodeName = 'commands') then - ParseTypes(xml) - else if (xml.NodeName = 'enums') then - AddObject(TvkTypeEnum.CreateFromXml(xml)) - else if (xml.NodeName = 'comment') then - fComment := xml.TextContent - else if (xml.NodeName = 'feature') then - EnableFeature(xml); - xml := xml.NextSibling; - end; - - WriteLn('generate header'); + if not FileExists(TemplateFile) then + raise Exception.Create('file does not exist: ' + TemplateFile); + tpl := TStringList.Create; + try + tpl.LoadFromFile(TemplateFile); + CurrentMark := 1; + WriteLn('read xml data'); + xml := fDocument.DocumentElement.FirstChild; + while Assigned(xml) do begin + if (xml.NodeName = 'types') or (xml.NodeName = 'commands') then + ParseTypes(xml) + else if (xml.NodeName = 'enums') then + AddObject(TvkTypeEnum.CreateFromXml(xml)) + else if (xml.NodeName = 'comment') then + tpl.Text := Trim(COMMENT_HEAD + Trim(xml.TextContent) + COMMENT_BREAK + COMMENT_CONTENT + COMMENT_TAIL) + sLineBreak + tpl.Text + else if (xml.NodeName = 'feature') then + EnableFeature(xml); + xml := xml.NextSibling; + end; + RemoveLines(tpl); + tpl.SaveToFile(OutputFile); + finally + FreeAndNil(tpl); + end; end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure THeaderGenerator.Clear; - procedure CreateBaseType(const aName: DOMString); - var o: TvkObject; + procedure CreateBaseType(const aName, aAlias, aParent: DOMString); + var t: TvkTypeSimple; begin - o := TvkTypeSimple.Create(otType); + t := TvkTypeSimple.Create(otType); try - o.Name := aName; - o.List := fObjects; - fObjects.Add(o); + t.Name := aName; + t.Alias := aAlias; + t.Parent := aParent; + t.List := fObjects; + t.Mark := 1; + fObjects.Add(t); except - FreeAndNil(o); + FreeAndNil(t); raise; end; end; begin - fComment := ''; fObjects.Clear; - CreateBaseType('void'); - CreateBaseType('uint16_t'); - CreateBaseType('uint32_t'); - CreateBaseType('uint64_t'); - CreateBaseType('int16_t'); - CreateBaseType('int32_t'); - CreateBaseType('int64_t'); - CreateBaseType('float'); - CreateBaseType('double'); - CreateBaseType('char'); - CreateBaseType('uint8_t'); - CreateBaseType('size_t'); - CreateBaseType('VkHandle'); + + CreateBaseType('PVkVoid', '', 'Pointer'); + CreateBaseType('VkHandle', '', 'Pointer'); + CreateBaseType('VkUint8', '', 'Byte'); + CreateBaseType('VkUint16', '', 'Word'); + CreateBaseType('VkUint32', '', 'Cardinal'); + CreateBaseType('VkUint64', '', 'QWord'); + CreateBaseType('VkInt16', '', 'SmallInt'); + CreateBaseType('VkInt32', '', 'Integer'); + CreateBaseType('VkInt64', '', 'Int64'); + CreateBaseType('VkFloat', '', 'Single'); + CreateBaseType('VkDouble', '', 'Double'); + CreateBaseType('VkChar', '', 'AnsiChar'); + CreateBaseType('VkSize', '', 'SizeUInt'); + + CreateBaseType('void', 'VkVoid', ''); + CreateBaseType('uint8_t', 'VkUint8', ''); + CreateBaseType('uint16_t', 'VkUint16', ''); + CreateBaseType('uint32_t', 'VkUint32', ''); + CreateBaseType('uint64_t', 'VkUint64', ''); + CreateBaseType('int16_t', 'VkInt16', ''); + CreateBaseType('int32_t', 'VkInt32', ''); + CreateBaseType('int64_t', 'VkInt64', ''); + CreateBaseType('float', 'VkFloat', ''); + CreateBaseType('double', 'VkDouble', ''); + CreateBaseType('char', 'VkChar', ''); + CreateBaseType('size_t', 'VkSize', ''); end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/projects/generator/generator.lpi b/projects/generator/generator.lpi index 6555182..5d332e7 100644 --- a/projects/generator/generator.lpi +++ b/projects/generator/generator.lpi @@ -29,7 +29,7 @@ - + @@ -47,7 +47,7 @@ - + @@ -59,6 +59,11 @@ + + + + + diff --git a/projects/generator/generator.lpr b/projects/generator/generator.lpr index ae4284a..084e78c 100644 --- a/projects/generator/generator.lpr +++ b/projects/generator/generator.lpr @@ -66,6 +66,8 @@ begin gen := THeaderGenerator.Create; try + gen.OutputFile := OutputFile; + gen.TemplateFile := TemplateFile; gen.ReadFile(InputFile); finally FreeAndNil(gen); @@ -75,8 +77,8 @@ end; begin try InputFile := ExtractFilePath(ParamStr(0)) + 'vk.xml'; - OutputFile := ExtractFilePath(ParamStr(0)) + 'vulkan.pas'; - TemplateFile := ExtractFilePath(ParamStr(0)) + 'vulkan.tpl'; + OutputFile := ExtractFilePath(ParamStr(0)) + 'Vulkan.pas'; + TemplateFile := ExtractFilePath(ParamStr(0)) + 'Vulkan.tpl'; ParseArgs; GenerateHeader; except diff --git a/projects/generator/generator.lps b/projects/generator/generator.lps index 2a4322d..25e961e 100644 --- a/projects/generator/generator.lps +++ b/projects/generator/generator.lps @@ -4,13 +4,12 @@ - + - - - + + @@ -18,9 +17,9 @@ - - - + + + @@ -28,170 +27,260 @@ - + - + - - + - + - - + - + - - + - + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - - + + - - + + - - + + - - + - + - + - + - + - + - + - + + + + + + +