Vulkan support.

Gtk port support. Breaks other platforms.

.gitmodules

@@ -13,6 +13,3 @@
 [submodule "shaders/glslang"]
 	path = external/glslang
 	url = https://github.com/KhronosGroup/glslang.git
-[submodule "vulkan/vulkan"]
-	path = external/vulkan-headers
-	url = https://github.com/KhronosGroup/Vulkan-Headers.git

external/SPIRV-Cross

@@ -1 +1 @@
-Subproject commit 1458bae62ec67ea7d12c5a13b740e23ed4bb226c
+Subproject commit 197a273fd494321157f40a962c51b5fa8c9c3581

external/VulkanMemoryAllocator-Hpp/LICENSE

@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>

external/VulkanMemoryAllocator-Hpp/include/vk_mem_alloc.hpp

@@ -0,0 +1,135 @@
+#ifndef VULKAN_MEMORY_ALLOCATOR_HPP
+#define VULKAN_MEMORY_ALLOCATOR_HPP
+
+#if !defined(AMD_VULKAN_MEMORY_ALLOCATOR_H)
+#include <vk_mem_alloc.h>
+#endif
+
+#include <vulkan/vulkan.hpp>
+
+#if !defined(VMA_HPP_NAMESPACE)
+#define VMA_HPP_NAMESPACE vma
+#endif
+
+#define VMA_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VMA_HPP_NAMESPACE)
+
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VMA_HPP_NAMESPACE {
+  struct Dispatcher {}; // VMA uses function pointers from VmaAllocator instead
+  class Allocator;
+
+  template<class T>
+  VULKAN_HPP_NAMESPACE::UniqueHandle<T, Dispatcher> createUniqueHandle(const T& t) VULKAN_HPP_NOEXCEPT {
+    return VULKAN_HPP_NAMESPACE::UniqueHandle<T, Dispatcher>(t);
+  }
+  template<class T, class O>
+  VULKAN_HPP_NAMESPACE::UniqueHandle<T, Dispatcher> createUniqueHandle(const T& t, const O* o) VULKAN_HPP_NOEXCEPT {
+    return VULKAN_HPP_NAMESPACE::UniqueHandle<T, Dispatcher>(t, o);
+  }
+  template<class F, class S, class O>
+  std::pair<VULKAN_HPP_NAMESPACE::UniqueHandle<F, Dispatcher>, VULKAN_HPP_NAMESPACE::UniqueHandle<S, Dispatcher>>
+          createUniqueHandle(const std::pair<F, S>& t, const O* o) VULKAN_HPP_NOEXCEPT {
+    return {
+            VULKAN_HPP_NAMESPACE::UniqueHandle<F, Dispatcher>(t.first, o),
+            VULKAN_HPP_NAMESPACE::UniqueHandle<S, Dispatcher>(t.second, o)
+    };
+  }
+
+  template<class T, class UniqueVectorAllocator, class VectorAllocator, class O>
+  std::vector<VULKAN_HPP_NAMESPACE::UniqueHandle<T, Dispatcher>, UniqueVectorAllocator>
+        createUniqueHandleVector(const std::vector<T, VectorAllocator>& vector, const O* o,
+                                 const UniqueVectorAllocator& vectorAllocator) VULKAN_HPP_NOEXCEPT {
+    std::vector<VULKAN_HPP_NAMESPACE::UniqueHandle<T, Dispatcher>, UniqueVectorAllocator> result(vectorAllocator);
+    result.reserve(vector.size());
+    for (const T& t : vector) result.emplace_back(t, o);
+    return result;
+  }
+
+  template<class T, class Owner> class Deleter {
+    const Owner* owner;
+  public:
+    Deleter() = default;
+    Deleter(const Owner* owner) VULKAN_HPP_NOEXCEPT : owner(owner) {}
+  protected:
+    void destroy(const T& t) VULKAN_HPP_NOEXCEPT; // Implemented manually for each handle type
+  };
+  template<class T> class Deleter<T, void> {
+  protected:
+    void destroy(const T& t) VULKAN_HPP_NOEXCEPT { t.destroy(); }
+  };
+}
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<Buffer, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<Buffer, VMA_HPP_NAMESPACE::Allocator>;
+  };
+  template<> struct UniqueHandleTraits<Image, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<Image, VMA_HPP_NAMESPACE::Allocator>;
+  };
+}
+namespace VMA_HPP_NAMESPACE {
+  using UniqueBuffer = VULKAN_HPP_NAMESPACE::UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatcher>;
+  using UniqueImage = VULKAN_HPP_NAMESPACE::UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatcher>;
+}
+#endif
+
+#include "vk_mem_alloc_enums.hpp"
+#include "vk_mem_alloc_handles.hpp"
+#include "vk_mem_alloc_structs.hpp"
+#include "vk_mem_alloc_funcs.hpp"
+
+namespace VMA_HPP_NAMESPACE {
+  
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+# define VMA_HPP_DESTROY_IMPL(NAME) \
+  template<> VULKAN_HPP_INLINE void VULKAN_HPP_NAMESPACE::UniqueHandleTraits<NAME, Dispatcher>::deleter::destroy(const NAME& t) VULKAN_HPP_NOEXCEPT
+
+  VMA_HPP_DESTROY_IMPL(VULKAN_HPP_NAMESPACE::Buffer) { owner->destroyBuffer(t, nullptr); }
+  VMA_HPP_DESTROY_IMPL(VULKAN_HPP_NAMESPACE::Image) { owner->destroyImage(t, nullptr); }
+  VMA_HPP_DESTROY_IMPL(Pool) { owner->destroyPool(t); }
+  VMA_HPP_DESTROY_IMPL(Allocation) { owner->freeMemory(t); }
+  VMA_HPP_DESTROY_IMPL(VirtualAllocation) { owner->virtualFree(t); }
+
+# undef VMA_HPP_DESTROY_IMPL
+#endif
+
+  template<class InstanceDispatcher, class DeviceDispatcher>
+  VULKAN_HPP_CONSTEXPR VulkanFunctions functionsFromDispatcher(InstanceDispatcher const * instance,
+                                                               DeviceDispatcher const * device) VULKAN_HPP_NOEXCEPT {
+    return VulkanFunctions {
+            instance->vkGetInstanceProcAddr,
+            instance->vkGetDeviceProcAddr,
+            instance->vkGetPhysicalDeviceProperties,
+            instance->vkGetPhysicalDeviceMemoryProperties,
+            device->vkAllocateMemory,
+            device->vkFreeMemory,
+            device->vkMapMemory,
+            device->vkUnmapMemory,
+            device->vkFlushMappedMemoryRanges,
+            device->vkInvalidateMappedMemoryRanges,
+            device->vkBindBufferMemory,
+            device->vkBindImageMemory,
+            device->vkGetBufferMemoryRequirements,
+            device->vkGetImageMemoryRequirements,
+            device->vkCreateBuffer,
+            device->vkDestroyBuffer,
+            device->vkCreateImage,
+            device->vkDestroyImage,
+            device->vkCmdCopyBuffer,
+            device->vkGetBufferMemoryRequirements2KHR ? device->vkGetBufferMemoryRequirements2KHR : device->vkGetBufferMemoryRequirements2,
+            device->vkGetImageMemoryRequirements2KHR ? device->vkGetImageMemoryRequirements2KHR : device->vkGetImageMemoryRequirements2,
+            device->vkBindBufferMemory2KHR ? device->vkBindBufferMemory2KHR : device->vkBindBufferMemory2,
+            device->vkBindImageMemory2KHR ? device->vkBindImageMemory2KHR : device->vkBindImageMemory2,
+            instance->vkGetPhysicalDeviceMemoryProperties2KHR ? instance->vkGetPhysicalDeviceMemoryProperties2KHR : instance->vkGetPhysicalDeviceMemoryProperties2,
+            device->vkGetDeviceBufferMemoryRequirements,
+            device->vkGetDeviceImageMemoryRequirements
+    };
+  }
+
+  template<class Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+  VULKAN_HPP_CONSTEXPR VulkanFunctions functionsFromDispatcher(Dispatch const & dispatch
+    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT {
+    return functionsFromDispatcher(&dispatch, &dispatch);
+  }
+}
+
+#endif

external/VulkanMemoryAllocator-Hpp/include/vk_mem_alloc_enums.hpp

@@ -0,0 +1,450 @@
+#ifndef VULKAN_MEMORY_ALLOCATOR_ENUMS_HPP
+#define VULKAN_MEMORY_ALLOCATOR_ENUMS_HPP
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class AllocatorCreateFlagBits : VmaAllocatorCreateFlags {
+    eExternallySynchronized = VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,
+    eKhrDedicatedAllocation = VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT,
+    eKhrBindMemory2 = VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT,
+    eExtMemoryBudget = VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT,
+    eAmdDeviceCoherentMemory = VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT,
+    eBufferDeviceAddress = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
+    eExtMemoryPriority = VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(AllocatorCreateFlagBits value) {
+    if (value == AllocatorCreateFlagBits::eExternallySynchronized) return "ExternallySynchronized";
+    if (value == AllocatorCreateFlagBits::eKhrDedicatedAllocation) return "KhrDedicatedAllocation";
+    if (value == AllocatorCreateFlagBits::eKhrBindMemory2) return "KhrBindMemory2";
+    if (value == AllocatorCreateFlagBits::eExtMemoryBudget) return "ExtMemoryBudget";
+    if (value == AllocatorCreateFlagBits::eAmdDeviceCoherentMemory) return "AmdDeviceCoherentMemory";
+    if (value == AllocatorCreateFlagBits::eBufferDeviceAddress) return "BufferDeviceAddress";
+    if (value == AllocatorCreateFlagBits::eExtMemoryPriority) return "ExtMemoryPriority";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct FlagTraits<VMA_HPP_NAMESPACE::AllocatorCreateFlagBits> {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR Flags<VMA_HPP_NAMESPACE::AllocatorCreateFlagBits> allFlags =
+        VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eExternallySynchronized
+      | VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eKhrDedicatedAllocation
+      | VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eKhrBindMemory2
+      | VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eExtMemoryBudget
+      | VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eAmdDeviceCoherentMemory
+      | VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eBufferDeviceAddress
+      | VMA_HPP_NAMESPACE::AllocatorCreateFlagBits::eExtMemoryPriority;
+  };
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  using AllocatorCreateFlags = VULKAN_HPP_NAMESPACE::Flags<AllocatorCreateFlagBits>;
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocatorCreateFlags operator|(AllocatorCreateFlagBits bit0, AllocatorCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return AllocatorCreateFlags(bit0) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocatorCreateFlags operator&(AllocatorCreateFlagBits bit0, AllocatorCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return AllocatorCreateFlags(bit0) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocatorCreateFlags operator^(AllocatorCreateFlagBits bit0, AllocatorCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return AllocatorCreateFlags(bit0) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocatorCreateFlags operator~(AllocatorCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+    return ~(AllocatorCreateFlags(bits));
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(AllocatorCreateFlags value) {
+    if (!value) return "{}";
+    std::string result;
+    if (value & AllocatorCreateFlagBits::eExternallySynchronized) result += "ExternallySynchronized | ";
+    if (value & AllocatorCreateFlagBits::eKhrDedicatedAllocation) result += "KhrDedicatedAllocation | ";
+    if (value & AllocatorCreateFlagBits::eKhrBindMemory2) result += "KhrBindMemory2 | ";
+    if (value & AllocatorCreateFlagBits::eExtMemoryBudget) result += "ExtMemoryBudget | ";
+    if (value & AllocatorCreateFlagBits::eAmdDeviceCoherentMemory) result += "AmdDeviceCoherentMemory | ";
+    if (value & AllocatorCreateFlagBits::eBufferDeviceAddress) result += "BufferDeviceAddress | ";
+    if (value & AllocatorCreateFlagBits::eExtMemoryPriority) result += "ExtMemoryPriority | ";
+    return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class MemoryUsage {
+    eUnknown = VMA_MEMORY_USAGE_UNKNOWN,
+    eGpuOnly = VMA_MEMORY_USAGE_GPU_ONLY,
+    eCpuOnly = VMA_MEMORY_USAGE_CPU_ONLY,
+    eCpuToGpu = VMA_MEMORY_USAGE_CPU_TO_GPU,
+    eGpuToCpu = VMA_MEMORY_USAGE_GPU_TO_CPU,
+    eCpuCopy = VMA_MEMORY_USAGE_CPU_COPY,
+    eGpuLazilyAllocated = VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED,
+    eAuto = VMA_MEMORY_USAGE_AUTO,
+    eAutoPreferDevice = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,
+    eAutoPreferHost = VMA_MEMORY_USAGE_AUTO_PREFER_HOST
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(MemoryUsage value) {
+    if (value == MemoryUsage::eUnknown) return "Unknown";
+    if (value == MemoryUsage::eGpuOnly) return "GpuOnly";
+    if (value == MemoryUsage::eCpuOnly) return "CpuOnly";
+    if (value == MemoryUsage::eCpuToGpu) return "CpuToGpu";
+    if (value == MemoryUsage::eGpuToCpu) return "GpuToCpu";
+    if (value == MemoryUsage::eCpuCopy) return "CpuCopy";
+    if (value == MemoryUsage::eGpuLazilyAllocated) return "GpuLazilyAllocated";
+    if (value == MemoryUsage::eAuto) return "Auto";
+    if (value == MemoryUsage::eAutoPreferDevice) return "AutoPreferDevice";
+    if (value == MemoryUsage::eAutoPreferHost) return "AutoPreferHost";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class AllocationCreateFlagBits : VmaAllocationCreateFlags {
+    eDedicatedMemory = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
+    eNeverAllocate = VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT,
+    eMapped = VMA_ALLOCATION_CREATE_MAPPED_BIT,
+    eUserDataCopyString = VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT,
+    eUpperAddress = VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT,
+    eDontBind = VMA_ALLOCATION_CREATE_DONT_BIND_BIT,
+    eWithinBudget = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT,
+    eCanAlias = VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT,
+    eHostAccessSequentialWrite = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
+    eHostAccessRandom = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
+    eHostAccessAllowTransferInstead = VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT,
+    eStrategyMinMemory = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT,
+    eStrategyMinTime = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT,
+    eStrategyMinOffset = VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
+    eStrategyBestFit = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
+    eStrategyFirstFit = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(AllocationCreateFlagBits value) {
+    if (value == AllocationCreateFlagBits::eDedicatedMemory) return "DedicatedMemory";
+    if (value == AllocationCreateFlagBits::eNeverAllocate) return "NeverAllocate";
+    if (value == AllocationCreateFlagBits::eMapped) return "Mapped";
+    if (value == AllocationCreateFlagBits::eUserDataCopyString) return "UserDataCopyString";
+    if (value == AllocationCreateFlagBits::eUpperAddress) return "UpperAddress";
+    if (value == AllocationCreateFlagBits::eDontBind) return "DontBind";
+    if (value == AllocationCreateFlagBits::eWithinBudget) return "WithinBudget";
+    if (value == AllocationCreateFlagBits::eCanAlias) return "CanAlias";
+    if (value == AllocationCreateFlagBits::eHostAccessSequentialWrite) return "HostAccessSequentialWrite";
+    if (value == AllocationCreateFlagBits::eHostAccessRandom) return "HostAccessRandom";
+    if (value == AllocationCreateFlagBits::eHostAccessAllowTransferInstead) return "HostAccessAllowTransferInstead";
+    if (value == AllocationCreateFlagBits::eStrategyMinMemory) return "StrategyMinMemory";
+    if (value == AllocationCreateFlagBits::eStrategyMinTime) return "StrategyMinTime";
+    if (value == AllocationCreateFlagBits::eStrategyMinOffset) return "StrategyMinOffset";
+    if (value == AllocationCreateFlagBits::eStrategyBestFit) return "StrategyBestFit";
+    if (value == AllocationCreateFlagBits::eStrategyFirstFit) return "StrategyFirstFit";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct FlagTraits<VMA_HPP_NAMESPACE::AllocationCreateFlagBits> {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR Flags<VMA_HPP_NAMESPACE::AllocationCreateFlagBits> allFlags =
+        VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eDedicatedMemory
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eNeverAllocate
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eMapped
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eUserDataCopyString
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eUpperAddress
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eDontBind
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eWithinBudget
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eCanAlias
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eHostAccessSequentialWrite
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eHostAccessRandom
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eHostAccessAllowTransferInstead
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eStrategyMinMemory
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eStrategyMinTime
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eStrategyMinOffset
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eStrategyBestFit
+      | VMA_HPP_NAMESPACE::AllocationCreateFlagBits::eStrategyFirstFit;
+  };
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  using AllocationCreateFlags = VULKAN_HPP_NAMESPACE::Flags<AllocationCreateFlagBits>;
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocationCreateFlags operator|(AllocationCreateFlagBits bit0, AllocationCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return AllocationCreateFlags(bit0) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocationCreateFlags operator&(AllocationCreateFlagBits bit0, AllocationCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return AllocationCreateFlags(bit0) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocationCreateFlags operator^(AllocationCreateFlagBits bit0, AllocationCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return AllocationCreateFlags(bit0) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AllocationCreateFlags operator~(AllocationCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+    return ~(AllocationCreateFlags(bits));
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(AllocationCreateFlags value) {
+    if (!value) return "{}";
+    std::string result;
+    if (value & AllocationCreateFlagBits::eDedicatedMemory) result += "DedicatedMemory | ";
+    if (value & AllocationCreateFlagBits::eNeverAllocate) result += "NeverAllocate | ";
+    if (value & AllocationCreateFlagBits::eMapped) result += "Mapped | ";
+    if (value & AllocationCreateFlagBits::eUserDataCopyString) result += "UserDataCopyString | ";
+    if (value & AllocationCreateFlagBits::eUpperAddress) result += "UpperAddress | ";
+    if (value & AllocationCreateFlagBits::eDontBind) result += "DontBind | ";
+    if (value & AllocationCreateFlagBits::eWithinBudget) result += "WithinBudget | ";
+    if (value & AllocationCreateFlagBits::eCanAlias) result += "CanAlias | ";
+    if (value & AllocationCreateFlagBits::eHostAccessSequentialWrite) result += "HostAccessSequentialWrite | ";
+    if (value & AllocationCreateFlagBits::eHostAccessRandom) result += "HostAccessRandom | ";
+    if (value & AllocationCreateFlagBits::eHostAccessAllowTransferInstead) result += "HostAccessAllowTransferInstead | ";
+    if (value & AllocationCreateFlagBits::eStrategyMinMemory) result += "StrategyMinMemory | ";
+    if (value & AllocationCreateFlagBits::eStrategyMinTime) result += "StrategyMinTime | ";
+    if (value & AllocationCreateFlagBits::eStrategyMinOffset) result += "StrategyMinOffset | ";
+    if (value & AllocationCreateFlagBits::eStrategyBestFit) result += "StrategyBestFit | ";
+    if (value & AllocationCreateFlagBits::eStrategyFirstFit) result += "StrategyFirstFit | ";
+    return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class PoolCreateFlagBits : VmaPoolCreateFlags {
+    eIgnoreBufferImageGranularity = VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT,
+    eLinearAlgorithm = VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(PoolCreateFlagBits value) {
+    if (value == PoolCreateFlagBits::eIgnoreBufferImageGranularity) return "IgnoreBufferImageGranularity";
+    if (value == PoolCreateFlagBits::eLinearAlgorithm) return "LinearAlgorithm";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct FlagTraits<VMA_HPP_NAMESPACE::PoolCreateFlagBits> {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR Flags<VMA_HPP_NAMESPACE::PoolCreateFlagBits> allFlags =
+        VMA_HPP_NAMESPACE::PoolCreateFlagBits::eIgnoreBufferImageGranularity
+      | VMA_HPP_NAMESPACE::PoolCreateFlagBits::eLinearAlgorithm;
+  };
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  using PoolCreateFlags = VULKAN_HPP_NAMESPACE::Flags<PoolCreateFlagBits>;
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PoolCreateFlags operator|(PoolCreateFlagBits bit0, PoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return PoolCreateFlags(bit0) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PoolCreateFlags operator&(PoolCreateFlagBits bit0, PoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return PoolCreateFlags(bit0) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PoolCreateFlags operator^(PoolCreateFlagBits bit0, PoolCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return PoolCreateFlags(bit0) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PoolCreateFlags operator~(PoolCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+    return ~(PoolCreateFlags(bits));
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(PoolCreateFlags value) {
+    if (!value) return "{}";
+    std::string result;
+    if (value & PoolCreateFlagBits::eIgnoreBufferImageGranularity) result += "IgnoreBufferImageGranularity | ";
+    if (value & PoolCreateFlagBits::eLinearAlgorithm) result += "LinearAlgorithm | ";
+    return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class DefragmentationFlagBits : VmaDefragmentationFlags {
+    eFlagAlgorithmFast = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT,
+    eFlagAlgorithmBalanced = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT,
+    eFlagAlgorithmFull = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT,
+    eFlagAlgorithmExtensive = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(DefragmentationFlagBits value) {
+    if (value == DefragmentationFlagBits::eFlagAlgorithmFast) return "FlagAlgorithmFast";
+    if (value == DefragmentationFlagBits::eFlagAlgorithmBalanced) return "FlagAlgorithmBalanced";
+    if (value == DefragmentationFlagBits::eFlagAlgorithmFull) return "FlagAlgorithmFull";
+    if (value == DefragmentationFlagBits::eFlagAlgorithmExtensive) return "FlagAlgorithmExtensive";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct FlagTraits<VMA_HPP_NAMESPACE::DefragmentationFlagBits> {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR Flags<VMA_HPP_NAMESPACE::DefragmentationFlagBits> allFlags =
+        VMA_HPP_NAMESPACE::DefragmentationFlagBits::eFlagAlgorithmFast
+      | VMA_HPP_NAMESPACE::DefragmentationFlagBits::eFlagAlgorithmBalanced
+      | VMA_HPP_NAMESPACE::DefragmentationFlagBits::eFlagAlgorithmFull
+      | VMA_HPP_NAMESPACE::DefragmentationFlagBits::eFlagAlgorithmExtensive;
+  };
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  using DefragmentationFlags = VULKAN_HPP_NAMESPACE::Flags<DefragmentationFlagBits>;
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DefragmentationFlags operator|(DefragmentationFlagBits bit0, DefragmentationFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return DefragmentationFlags(bit0) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DefragmentationFlags operator&(DefragmentationFlagBits bit0, DefragmentationFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return DefragmentationFlags(bit0) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DefragmentationFlags operator^(DefragmentationFlagBits bit0, DefragmentationFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return DefragmentationFlags(bit0) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DefragmentationFlags operator~(DefragmentationFlagBits bits) VULKAN_HPP_NOEXCEPT {
+    return ~(DefragmentationFlags(bits));
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(DefragmentationFlags value) {
+    if (!value) return "{}";
+    std::string result;
+    if (value & DefragmentationFlagBits::eFlagAlgorithmFast) result += "FlagAlgorithmFast | ";
+    if (value & DefragmentationFlagBits::eFlagAlgorithmBalanced) result += "FlagAlgorithmBalanced | ";
+    if (value & DefragmentationFlagBits::eFlagAlgorithmFull) result += "FlagAlgorithmFull | ";
+    if (value & DefragmentationFlagBits::eFlagAlgorithmExtensive) result += "FlagAlgorithmExtensive | ";
+    return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class DefragmentationMoveOperation {
+    eCopy = VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY,
+    eIgnore = VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE,
+    eDestroy = VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(DefragmentationMoveOperation value) {
+    if (value == DefragmentationMoveOperation::eCopy) return "Copy";
+    if (value == DefragmentationMoveOperation::eIgnore) return "Ignore";
+    if (value == DefragmentationMoveOperation::eDestroy) return "Destroy";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class VirtualBlockCreateFlagBits : VmaVirtualBlockCreateFlags {
+    eLinearAlgorithm = VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(VirtualBlockCreateFlagBits value) {
+    if (value == VirtualBlockCreateFlagBits::eLinearAlgorithm) return "LinearAlgorithm";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct FlagTraits<VMA_HPP_NAMESPACE::VirtualBlockCreateFlagBits> {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR Flags<VMA_HPP_NAMESPACE::VirtualBlockCreateFlagBits> allFlags =
+        VMA_HPP_NAMESPACE::VirtualBlockCreateFlagBits::eLinearAlgorithm;
+  };
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  using VirtualBlockCreateFlags = VULKAN_HPP_NAMESPACE::Flags<VirtualBlockCreateFlagBits>;
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualBlockCreateFlags operator|(VirtualBlockCreateFlagBits bit0, VirtualBlockCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return VirtualBlockCreateFlags(bit0) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualBlockCreateFlags operator&(VirtualBlockCreateFlagBits bit0, VirtualBlockCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return VirtualBlockCreateFlags(bit0) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualBlockCreateFlags operator^(VirtualBlockCreateFlagBits bit0, VirtualBlockCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return VirtualBlockCreateFlags(bit0) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualBlockCreateFlags operator~(VirtualBlockCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+    return ~(VirtualBlockCreateFlags(bits));
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(VirtualBlockCreateFlags value) {
+    if (!value) return "{}";
+    std::string result;
+    if (value & VirtualBlockCreateFlagBits::eLinearAlgorithm) result += "LinearAlgorithm | ";
+    return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+  }
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  enum class VirtualAllocationCreateFlagBits : VmaVirtualAllocationCreateFlags {
+    eUpperAddress = VMA_VIRTUAL_ALLOCATION_CREATE_UPPER_ADDRESS_BIT,
+    eStrategyMinMemory = VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT,
+    eStrategyMinTime = VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT,
+    eStrategyMinOffset = VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT
+  };
+
+  VULKAN_HPP_INLINE std::string to_string(VirtualAllocationCreateFlagBits value) {
+    if (value == VirtualAllocationCreateFlagBits::eUpperAddress) return "UpperAddress";
+    if (value == VirtualAllocationCreateFlagBits::eStrategyMinMemory) return "StrategyMinMemory";
+    if (value == VirtualAllocationCreateFlagBits::eStrategyMinTime) return "StrategyMinTime";
+    if (value == VirtualAllocationCreateFlagBits::eStrategyMinOffset) return "StrategyMinOffset";
+    return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString(static_cast<uint32_t>(value)) + " )";
+  }
+}
+
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct FlagTraits<VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits> {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR Flags<VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits> allFlags =
+        VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits::eUpperAddress
+      | VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits::eStrategyMinMemory
+      | VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits::eStrategyMinTime
+      | VMA_HPP_NAMESPACE::VirtualAllocationCreateFlagBits::eStrategyMinOffset;
+  };
+}
+
+namespace VMA_HPP_NAMESPACE {
+
+  using VirtualAllocationCreateFlags = VULKAN_HPP_NAMESPACE::Flags<VirtualAllocationCreateFlagBits>;
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualAllocationCreateFlags operator|(VirtualAllocationCreateFlagBits bit0, VirtualAllocationCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return VirtualAllocationCreateFlags(bit0) | bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualAllocationCreateFlags operator&(VirtualAllocationCreateFlagBits bit0, VirtualAllocationCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return VirtualAllocationCreateFlags(bit0) & bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualAllocationCreateFlags operator^(VirtualAllocationCreateFlagBits bit0, VirtualAllocationCreateFlagBits bit1) VULKAN_HPP_NOEXCEPT {
+    return VirtualAllocationCreateFlags(bit0) ^ bit1;
+  }
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VirtualAllocationCreateFlags operator~(VirtualAllocationCreateFlagBits bits) VULKAN_HPP_NOEXCEPT {
+    return ~(VirtualAllocationCreateFlags(bits));
+  }
+
+  VULKAN_HPP_INLINE std::string to_string(VirtualAllocationCreateFlags value) {
+    if (!value) return "{}";
+    std::string result;
+    if (value & VirtualAllocationCreateFlagBits::eUpperAddress) result += "UpperAddress | ";
+    if (value & VirtualAllocationCreateFlagBits::eStrategyMinMemory) result += "StrategyMinMemory | ";
+    if (value & VirtualAllocationCreateFlagBits::eStrategyMinTime) result += "StrategyMinTime | ";
+    if (value & VirtualAllocationCreateFlagBits::eStrategyMinOffset) result += "StrategyMinOffset | ";
+    return "{ " + result.substr( 0, result.size() - 3 ) + " }";
+  }
+}
+
+#endif

external/VulkanMemoryAllocator-Hpp/include/vk_mem_alloc_handles.hpp

@@ -0,0 +1,929 @@
+#ifndef VULKAN_MEMORY_ALLOCATOR_HANDLES_HPP
+#define VULKAN_MEMORY_ALLOCATOR_HANDLES_HPP
+
+namespace VMA_HPP_NAMESPACE {
+
+  struct DeviceMemoryCallbacks;
+  struct VulkanFunctions;
+  struct AllocatorCreateInfo;
+  struct AllocatorInfo;
+  struct Statistics;
+  struct DetailedStatistics;
+  struct TotalStatistics;
+  struct Budget;
+  struct AllocationCreateInfo;
+  struct PoolCreateInfo;
+  struct AllocationInfo;
+  struct DefragmentationInfo;
+  struct DefragmentationMove;
+  struct DefragmentationPassMoveInfo;
+  struct DefragmentationStats;
+  struct VirtualBlockCreateInfo;
+  struct VirtualAllocationCreateInfo;
+  struct VirtualAllocationInfo;
+
+  class Pool;
+  class Allocation;
+  class DefragmentationContext;
+  class VirtualAllocation;
+  class Allocator;
+  class VirtualBlock;
+}
+
+
+namespace VMA_HPP_NAMESPACE {
+  class Pool {
+  public:
+    using CType      = VmaPool;
+    using NativeType = VmaPool;
+  public:
+    VULKAN_HPP_CONSTEXPR         Pool() = default;
+    VULKAN_HPP_CONSTEXPR         Pool(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+    VULKAN_HPP_TYPESAFE_EXPLICIT Pool(VmaPool pool) VULKAN_HPP_NOEXCEPT : m_pool(pool) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Pool& operator=(VmaPool pool) VULKAN_HPP_NOEXCEPT {
+      m_pool = pool;
+      return *this;
+    }
+#endif
+
+    Pool& operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+      m_pool = {};
+      return *this;
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>(Pool const &) const = default;
+#else
+    bool operator==(Pool const & rhs) const VULKAN_HPP_NOEXCEPT {
+      return m_pool == rhs.m_pool;
+    }
+#endif
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VmaPool() const VULKAN_HPP_NOEXCEPT {
+      return m_pool;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+      return m_pool != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT {
+      return m_pool == VK_NULL_HANDLE;
+    }
+
+  private:
+    VmaPool m_pool = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT(sizeof(Pool) == sizeof(VmaPool),
+                           "handle and wrapper have different size!");
+}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<VMA_HPP_NAMESPACE::Pool, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<VMA_HPP_NAMESPACE::Pool, VMA_HPP_NAMESPACE::Allocator>;
+  };
+}
+namespace VMA_HPP_NAMESPACE { using UniquePool = VULKAN_HPP_NAMESPACE::UniqueHandle<Pool, Dispatcher>; }
+#endif
+
+namespace VMA_HPP_NAMESPACE {
+  class Allocation {
+  public:
+    using CType      = VmaAllocation;
+    using NativeType = VmaAllocation;
+  public:
+    VULKAN_HPP_CONSTEXPR         Allocation() = default;
+    VULKAN_HPP_CONSTEXPR         Allocation(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+    VULKAN_HPP_TYPESAFE_EXPLICIT Allocation(VmaAllocation allocation) VULKAN_HPP_NOEXCEPT : m_allocation(allocation) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Allocation& operator=(VmaAllocation allocation) VULKAN_HPP_NOEXCEPT {
+      m_allocation = allocation;
+      return *this;
+    }
+#endif
+
+    Allocation& operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+      m_allocation = {};
+      return *this;
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>(Allocation const &) const = default;
+#else
+    bool operator==(Allocation const & rhs) const VULKAN_HPP_NOEXCEPT {
+      return m_allocation == rhs.m_allocation;
+    }
+#endif
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VmaAllocation() const VULKAN_HPP_NOEXCEPT {
+      return m_allocation;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+      return m_allocation != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT {
+      return m_allocation == VK_NULL_HANDLE;
+    }
+
+  private:
+    VmaAllocation m_allocation = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT(sizeof(Allocation) == sizeof(VmaAllocation),
+                           "handle and wrapper have different size!");
+}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<VMA_HPP_NAMESPACE::Allocation, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<VMA_HPP_NAMESPACE::Allocation, VMA_HPP_NAMESPACE::Allocator>;
+  };
+}
+namespace VMA_HPP_NAMESPACE { using UniqueAllocation = VULKAN_HPP_NAMESPACE::UniqueHandle<Allocation, Dispatcher>; }
+#endif
+
+namespace VMA_HPP_NAMESPACE {
+  class DefragmentationContext {
+  public:
+    using CType      = VmaDefragmentationContext;
+    using NativeType = VmaDefragmentationContext;
+  public:
+    VULKAN_HPP_CONSTEXPR         DefragmentationContext() = default;
+    VULKAN_HPP_CONSTEXPR         DefragmentationContext(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+    VULKAN_HPP_TYPESAFE_EXPLICIT DefragmentationContext(VmaDefragmentationContext defragmentationContext) VULKAN_HPP_NOEXCEPT : m_defragmentationContext(defragmentationContext) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    DefragmentationContext& operator=(VmaDefragmentationContext defragmentationContext) VULKAN_HPP_NOEXCEPT {
+      m_defragmentationContext = defragmentationContext;
+      return *this;
+    }
+#endif
+
+    DefragmentationContext& operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+      m_defragmentationContext = {};
+      return *this;
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>(DefragmentationContext const &) const = default;
+#else
+    bool operator==(DefragmentationContext const & rhs) const VULKAN_HPP_NOEXCEPT {
+      return m_defragmentationContext == rhs.m_defragmentationContext;
+    }
+#endif
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VmaDefragmentationContext() const VULKAN_HPP_NOEXCEPT {
+      return m_defragmentationContext;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+      return m_defragmentationContext != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT {
+      return m_defragmentationContext == VK_NULL_HANDLE;
+    }
+
+  private:
+    VmaDefragmentationContext m_defragmentationContext = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT(sizeof(DefragmentationContext) == sizeof(VmaDefragmentationContext),
+                           "handle and wrapper have different size!");
+}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<VMA_HPP_NAMESPACE::DefragmentationContext, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<VMA_HPP_NAMESPACE::DefragmentationContext, void>;
+  };
+}
+namespace VMA_HPP_NAMESPACE { using UniqueDefragmentationContext = VULKAN_HPP_NAMESPACE::UniqueHandle<DefragmentationContext, Dispatcher>; }
+#endif
+
+namespace VMA_HPP_NAMESPACE {
+  class Allocator {
+  public:
+    using CType      = VmaAllocator;
+    using NativeType = VmaAllocator;
+  public:
+    VULKAN_HPP_CONSTEXPR         Allocator() = default;
+    VULKAN_HPP_CONSTEXPR         Allocator(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+    VULKAN_HPP_TYPESAFE_EXPLICIT Allocator(VmaAllocator allocator) VULKAN_HPP_NOEXCEPT : m_allocator(allocator) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    Allocator& operator=(VmaAllocator allocator) VULKAN_HPP_NOEXCEPT {
+      m_allocator = allocator;
+      return *this;
+    }
+#endif
+
+    Allocator& operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+      m_allocator = {};
+      return *this;
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>(Allocator const &) const = default;
+#else
+    bool operator==(Allocator const & rhs) const VULKAN_HPP_NOEXCEPT {
+      return m_allocator == rhs.m_allocator;
+    }
+#endif
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VmaAllocator() const VULKAN_HPP_NOEXCEPT {
+      return m_allocator;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+      return m_allocator != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT {
+      return m_allocator == VK_NULL_HANDLE;
+    }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void destroy() const;
+#else
+    void destroy() const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS AllocatorInfo getAllocatorInfo() const;
+#endif
+    void getAllocatorInfo(AllocatorInfo* allocatorInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS const VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties* getPhysicalDeviceProperties() const;
+#endif
+    void getPhysicalDeviceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties** physicalDeviceProperties) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS const VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties* getMemoryProperties() const;
+#endif
+    void getMemoryProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties** physicalDeviceMemoryProperties) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NAMESPACE::MemoryPropertyFlags getMemoryTypeProperties(uint32_t memoryTypeIndex) const;
+#endif
+    void getMemoryTypeProperties(uint32_t memoryTypeIndex,
+                                 VULKAN_HPP_NAMESPACE::MemoryPropertyFlags* flags) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void setCurrentFrameIndex(uint32_t frameIndex) const;
+#else
+    void setCurrentFrameIndex(uint32_t frameIndex) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS TotalStatistics calculateStatistics() const;
+#endif
+    void calculateStatistics(TotalStatistics* stats) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename VectorAllocator = std::allocator<Budget>,
+             typename B = VectorAllocator,
+             typename std::enable_if<std::is_same<typename B::value_type, Budget>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS std::vector<Budget, VectorAllocator> getHeapBudgets(VectorAllocator& vectorAllocator) const;
+
+    template<typename VectorAllocator = std::allocator<Budget>>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS std::vector<Budget, VectorAllocator> getHeapBudgets() const;
+#endif
+    void getHeapBudgets(Budget* budgets) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<uint32_t>::type findMemoryTypeIndex(uint32_t memoryTypeBits,
+                                                                                                                               const AllocationCreateInfo& allocationCreateInfo) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result findMemoryTypeIndex(uint32_t memoryTypeBits,
+                                                                          const AllocationCreateInfo* allocationCreateInfo,
+                                                                          uint32_t* memoryTypeIndex) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<uint32_t>::type findMemoryTypeIndexForBufferInfo(const VULKAN_HPP_NAMESPACE::BufferCreateInfo& bufferCreateInfo,
+                                                                                                                                            const AllocationCreateInfo& allocationCreateInfo) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result findMemoryTypeIndexForBufferInfo(const VULKAN_HPP_NAMESPACE::BufferCreateInfo* bufferCreateInfo,
+                                                                                       const AllocationCreateInfo* allocationCreateInfo,
+                                                                                       uint32_t* memoryTypeIndex) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<uint32_t>::type findMemoryTypeIndexForImageInfo(const VULKAN_HPP_NAMESPACE::ImageCreateInfo& imageCreateInfo,
+                                                                                                                                           const AllocationCreateInfo& allocationCreateInfo) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result findMemoryTypeIndexForImageInfo(const VULKAN_HPP_NAMESPACE::ImageCreateInfo* imageCreateInfo,
+                                                                                      const AllocationCreateInfo* allocationCreateInfo,
+                                                                                      uint32_t* memoryTypeIndex) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<Pool>::type createPool(const PoolCreateInfo& createInfo) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniquePool>::type createPoolUnique(const PoolCreateInfo& createInfo) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createPool(const PoolCreateInfo* createInfo,
+                                                                 Pool* pool) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void destroyPool(Pool pool) const;
+#else
+    void destroyPool(Pool pool) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS Statistics getPoolStatistics(Pool pool) const;
+#endif
+    void getPoolStatistics(Pool pool,
+                           Statistics* poolStats) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS DetailedStatistics calculatePoolStatistics(Pool pool) const;
+#endif
+    void calculatePoolStatistics(Pool pool,
+                                 DetailedStatistics* poolStats) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type checkPoolCorruption(Pool pool) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result checkPoolCorruption(Pool pool) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS const char* getPoolName(Pool pool) const;
+#endif
+    void getPoolName(Pool pool,
+                     const char** name) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void setPoolName(Pool pool,
+                     const char* name) const;
+#else
+    void setPoolName(Pool pool,
+                     const char* name) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<Allocation>::type allocateMemory(const VULKAN_HPP_NAMESPACE::MemoryRequirements& vkMemoryRequirements,
+                                                                                                                            const AllocationCreateInfo& createInfo,
+                                                                                                                            VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniqueAllocation>::type allocateMemoryUnique(const VULKAN_HPP_NAMESPACE::MemoryRequirements& vkMemoryRequirements,
+                                                                                                                                        const AllocationCreateInfo& createInfo,
+                                                                                                                                        VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result allocateMemory(const VULKAN_HPP_NAMESPACE::MemoryRequirements* vkMemoryRequirements,
+                                                                     const AllocationCreateInfo* createInfo,
+                                                                     Allocation* allocation,
+                                                                     AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template<typename VectorAllocator = std::allocator<Allocation>,
+             typename B = VectorAllocator,
+             typename std::enable_if<std::is_same<typename B::value_type, Allocation>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::vector<Allocation, VectorAllocator>>::type allocateMemoryPages(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryRequirements> vkMemoryRequirements,
+                                                                                                                                                               VULKAN_HPP_NAMESPACE::ArrayProxy<const AllocationCreateInfo> createInfo,
+                                                                                                                                                               VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<AllocationInfo> allocationInfo,
+                                                                                                                                                               VectorAllocator& vectorAllocator) const;
+
+    template<typename VectorAllocator = std::allocator<Allocation>>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::vector<Allocation, VectorAllocator>>::type allocateMemoryPages(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryRequirements> vkMemoryRequirements,
+                                                                                                                                                               VULKAN_HPP_NAMESPACE::ArrayProxy<const AllocationCreateInfo> createInfo,
+                                                                                                                                                               VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template<typename VectorAllocator = std::allocator<UniqueAllocation>,
+             typename B = VectorAllocator,
+             typename std::enable_if<std::is_same<typename B::value_type, UniqueAllocation>::value, int>::type = 0>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::vector<UniqueAllocation, VectorAllocator>>::type allocateMemoryPagesUnique(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryRequirements> vkMemoryRequirements,
+                                                                                                                                                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const AllocationCreateInfo> createInfo,
+                                                                                                                                                                           VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<AllocationInfo> allocationInfo,
+                                                                                                                                                                           VectorAllocator& vectorAllocator) const;
+
+    template<typename VectorAllocator = std::allocator<UniqueAllocation>>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::vector<UniqueAllocation, VectorAllocator>>::type allocateMemoryPagesUnique(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryRequirements> vkMemoryRequirements,
+                                                                                                                                                                           VULKAN_HPP_NAMESPACE::ArrayProxy<const AllocationCreateInfo> createInfo,
+                                                                                                                                                                           VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result allocateMemoryPages(const VULKAN_HPP_NAMESPACE::MemoryRequirements* vkMemoryRequirements,
+                                                                          const AllocationCreateInfo* createInfo,
+                                                                          size_t allocationCount,
+                                                                          Allocation* allocations,
+                                                                          AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<Allocation>::type allocateMemoryForBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer,
+                                                                                                                                     const AllocationCreateInfo& createInfo,
+                                                                                                                                     VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniqueAllocation>::type allocateMemoryForBufferUnique(VULKAN_HPP_NAMESPACE::Buffer buffer,
+                                                                                                                                                 const AllocationCreateInfo& createInfo,
+                                                                                                                                                 VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result allocateMemoryForBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer,
+                                                                              const AllocationCreateInfo* createInfo,
+                                                                              Allocation* allocation,
+                                                                              AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<Allocation>::type allocateMemoryForImage(VULKAN_HPP_NAMESPACE::Image image,
+                                                                                                                                    const AllocationCreateInfo& createInfo,
+                                                                                                                                    VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniqueAllocation>::type allocateMemoryForImageUnique(VULKAN_HPP_NAMESPACE::Image image,
+                                                                                                                                                const AllocationCreateInfo& createInfo,
+                                                                                                                                                VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result allocateMemoryForImage(VULKAN_HPP_NAMESPACE::Image image,
+                                                                             const AllocationCreateInfo* createInfo,
+                                                                             Allocation* allocation,
+                                                                             AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void freeMemory(const Allocation allocation) const;
+#else
+    void freeMemory(const Allocation allocation) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void freeMemoryPages(VULKAN_HPP_NAMESPACE::ArrayProxy<const Allocation> allocations) const;
+#endif
+    void freeMemoryPages(size_t allocationCount,
+                         const Allocation* allocations) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS AllocationInfo getAllocationInfo(Allocation allocation) const;
+#endif
+    void getAllocationInfo(Allocation allocation,
+                           AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void setAllocationUserData(Allocation allocation,
+                               void* userData) const;
+#else
+    void setAllocationUserData(Allocation allocation,
+                               void* userData) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void setAllocationName(Allocation allocation,
+                           const char* name) const;
+#else
+    void setAllocationName(Allocation allocation,
+                           const char* name) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NAMESPACE::MemoryPropertyFlags getAllocationMemoryProperties(Allocation allocation) const;
+#endif
+    void getAllocationMemoryProperties(Allocation allocation,
+                                       VULKAN_HPP_NAMESPACE::MemoryPropertyFlags* flags) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<void*>::type mapMemory(Allocation allocation) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result mapMemory(Allocation allocation,
+                                                                void** data) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void unmapMemory(Allocation allocation) const;
+#else
+    void unmapMemory(Allocation allocation) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type flushAllocation(Allocation allocation,
+                                                                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                               VULKAN_HPP_NAMESPACE::DeviceSize size) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result flushAllocation(Allocation allocation,
+                                                                      VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                      VULKAN_HPP_NAMESPACE::DeviceSize size) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type invalidateAllocation(Allocation allocation,
+                                                                                    VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                                    VULKAN_HPP_NAMESPACE::DeviceSize size) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result invalidateAllocation(Allocation allocation,
+                                                                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
+                                                                           VULKAN_HPP_NAMESPACE::DeviceSize size) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type flushAllocations(VULKAN_HPP_NAMESPACE::ArrayProxy<const Allocation> allocations,
+                                                                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> offsets,
+                                                                                VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> sizes) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result flushAllocations(uint32_t allocationCount,
+                                                                       const Allocation* allocations,
+                                                                       const VULKAN_HPP_NAMESPACE::DeviceSize* offsets,
+                                                                       const VULKAN_HPP_NAMESPACE::DeviceSize* sizes) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type invalidateAllocations(VULKAN_HPP_NAMESPACE::ArrayProxy<const Allocation> allocations,
+                                                                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> offsets,
+                                                                                     VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> sizes) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result invalidateAllocations(uint32_t allocationCount,
+                                                                            const Allocation* allocations,
+                                                                            const VULKAN_HPP_NAMESPACE::DeviceSize* offsets,
+                                                                            const VULKAN_HPP_NAMESPACE::DeviceSize* sizes) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type checkCorruption(uint32_t memoryTypeBits) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result checkCorruption(uint32_t memoryTypeBits) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<DefragmentationContext>::type beginDefragmentation(const DefragmentationInfo& info) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result beginDefragmentation(const DefragmentationInfo* info,
+                                                                           DefragmentationContext* context) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void endDefragmentation(DefragmentationContext context,
+                            VULKAN_HPP_NAMESPACE::Optional<DefragmentationStats> stats = nullptr) const;
+#endif
+    void endDefragmentation(DefragmentationContext context,
+                            DefragmentationStats* stats) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<DefragmentationPassMoveInfo>::type beginDefragmentationPass(DefragmentationContext context) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result beginDefragmentationPass(DefragmentationContext context,
+                                                                               DefragmentationPassMoveInfo* passInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<DefragmentationPassMoveInfo>::type endDefragmentationPass(DefragmentationContext context) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result endDefragmentationPass(DefragmentationContext context,
+                                                                             DefragmentationPassMoveInfo* passInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type bindBufferMemory(Allocation allocation,
+                                                                                VULKAN_HPP_NAMESPACE::Buffer buffer) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result bindBufferMemory(Allocation allocation,
+                                                                       VULKAN_HPP_NAMESPACE::Buffer buffer) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type bindBufferMemory2(Allocation allocation,
+                                                                                 VULKAN_HPP_NAMESPACE::DeviceSize allocationLocalOffset,
+                                                                                 VULKAN_HPP_NAMESPACE::Buffer buffer,
+                                                                                 const void* next) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result bindBufferMemory2(Allocation allocation,
+                                                                        VULKAN_HPP_NAMESPACE::DeviceSize allocationLocalOffset,
+                                                                        VULKAN_HPP_NAMESPACE::Buffer buffer,
+                                                                        const void* next) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type bindImageMemory(Allocation allocation,
+                                                                               VULKAN_HPP_NAMESPACE::Image image) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result bindImageMemory(Allocation allocation,
+                                                                      VULKAN_HPP_NAMESPACE::Image image) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type bindImageMemory2(Allocation allocation,
+                                                                                VULKAN_HPP_NAMESPACE::DeviceSize allocationLocalOffset,
+                                                                                VULKAN_HPP_NAMESPACE::Image image,
+                                                                                const void* next) const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result bindImageMemory2(Allocation allocation,
+                                                                       VULKAN_HPP_NAMESPACE::DeviceSize allocationLocalOffset,
+                                                                       VULKAN_HPP_NAMESPACE::Image image,
+                                                                       const void* next) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::Buffer, Allocation>>::type createBuffer(const VULKAN_HPP_NAMESPACE::BufferCreateInfo& bufferCreateInfo,
+                                                                                                                                                                   const AllocationCreateInfo& allocationCreateInfo,
+                                                                                                                                                                   VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::pair<UniqueBuffer, UniqueAllocation>>::type createBufferUnique(const VULKAN_HPP_NAMESPACE::BufferCreateInfo& bufferCreateInfo,
+                                                                                                                                                               const AllocationCreateInfo& allocationCreateInfo,
+                                                                                                                                                               VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createBuffer(const VULKAN_HPP_NAMESPACE::BufferCreateInfo* bufferCreateInfo,
+                                                                   const AllocationCreateInfo* allocationCreateInfo,
+                                                                   VULKAN_HPP_NAMESPACE::Buffer* buffer,
+                                                                   Allocation* allocation,
+                                                                   AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::Buffer, Allocation>>::type createBufferWithAlignment(const VULKAN_HPP_NAMESPACE::BufferCreateInfo& bufferCreateInfo,
+                                                                                                                                                                                const AllocationCreateInfo& allocationCreateInfo,
+                                                                                                                                                                                VULKAN_HPP_NAMESPACE::DeviceSize minAlignment,
+                                                                                                                                                                                VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::pair<UniqueBuffer, UniqueAllocation>>::type createBufferWithAlignmentUnique(const VULKAN_HPP_NAMESPACE::BufferCreateInfo& bufferCreateInfo,
+                                                                                                                                                                            const AllocationCreateInfo& allocationCreateInfo,
+                                                                                                                                                                            VULKAN_HPP_NAMESPACE::DeviceSize minAlignment,
+                                                                                                                                                                            VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createBufferWithAlignment(const VULKAN_HPP_NAMESPACE::BufferCreateInfo* bufferCreateInfo,
+                                                                                const AllocationCreateInfo* allocationCreateInfo,
+                                                                                VULKAN_HPP_NAMESPACE::DeviceSize minAlignment,
+                                                                                VULKAN_HPP_NAMESPACE::Buffer* buffer,
+                                                                                Allocation* allocation,
+                                                                                AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type createAliasingBuffer(Allocation allocation,
+                                                                                                                                                    const VULKAN_HPP_NAMESPACE::BufferCreateInfo& bufferCreateInfo) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createAliasingBuffer(Allocation allocation,
+                                                                           const VULKAN_HPP_NAMESPACE::BufferCreateInfo* bufferCreateInfo,
+                                                                           VULKAN_HPP_NAMESPACE::Buffer* buffer) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void destroyBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer,
+                       Allocation allocation) const;
+#else
+    void destroyBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer,
+                       Allocation allocation) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::Image, Allocation>>::type createImage(const VULKAN_HPP_NAMESPACE::ImageCreateInfo& imageCreateInfo,
+                                                                                                                                                                 const AllocationCreateInfo& allocationCreateInfo,
+                                                                                                                                                                 VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<std::pair<UniqueImage, UniqueAllocation>>::type createImageUnique(const VULKAN_HPP_NAMESPACE::ImageCreateInfo& imageCreateInfo,
+                                                                                                                                                             const AllocationCreateInfo& allocationCreateInfo,
+                                                                                                                                                             VULKAN_HPP_NAMESPACE::Optional<AllocationInfo> allocationInfo = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createImage(const VULKAN_HPP_NAMESPACE::ImageCreateInfo* imageCreateInfo,
+                                                                  const AllocationCreateInfo* allocationCreateInfo,
+                                                                  VULKAN_HPP_NAMESPACE::Image* image,
+                                                                  Allocation* allocation,
+                                                                  AllocationInfo* allocationInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type createAliasingImage(Allocation allocation,
+                                                                                                                                                  const VULKAN_HPP_NAMESPACE::ImageCreateInfo& imageCreateInfo) const;
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createAliasingImage(Allocation allocation,
+                                                                          const VULKAN_HPP_NAMESPACE::ImageCreateInfo* imageCreateInfo,
+                                                                          VULKAN_HPP_NAMESPACE::Image* image) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void destroyImage(VULKAN_HPP_NAMESPACE::Image image,
+                      Allocation allocation) const;
+#else
+    void destroyImage(VULKAN_HPP_NAMESPACE::Image image,
+                      Allocation allocation) const;
+#endif
+
+#if VMA_STATS_STRING_ENABLED
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS char* buildStatsString(VULKAN_HPP_NAMESPACE::Bool32 detailedMap) const;
+#endif
+    void buildStatsString(char** statsString,
+                          VULKAN_HPP_NAMESPACE::Bool32 detailedMap) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void freeStatsString(char* statsString) const;
+#else
+    void freeStatsString(char* statsString) const;
+#endif
+
+#endif
+  private:
+    VmaAllocator m_allocator = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT(sizeof(Allocator) == sizeof(VmaAllocator),
+                           "handle and wrapper have different size!");
+}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<VMA_HPP_NAMESPACE::Allocator, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<VMA_HPP_NAMESPACE::Allocator, void>;
+  };
+}
+namespace VMA_HPP_NAMESPACE { using UniqueAllocator = VULKAN_HPP_NAMESPACE::UniqueHandle<Allocator, Dispatcher>; }
+#endif
+
+namespace VMA_HPP_NAMESPACE {
+  class VirtualAllocation {
+  public:
+    using CType      = VmaVirtualAllocation;
+    using NativeType = VmaVirtualAllocation;
+  public:
+    VULKAN_HPP_CONSTEXPR         VirtualAllocation() = default;
+    VULKAN_HPP_CONSTEXPR         VirtualAllocation(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+    VULKAN_HPP_TYPESAFE_EXPLICIT VirtualAllocation(VmaVirtualAllocation virtualAllocation) VULKAN_HPP_NOEXCEPT : m_virtualAllocation(virtualAllocation) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    VirtualAllocation& operator=(VmaVirtualAllocation virtualAllocation) VULKAN_HPP_NOEXCEPT {
+      m_virtualAllocation = virtualAllocation;
+      return *this;
+    }
+#endif
+
+    VirtualAllocation& operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+      m_virtualAllocation = {};
+      return *this;
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>(VirtualAllocation const &) const = default;
+#else
+    bool operator==(VirtualAllocation const & rhs) const VULKAN_HPP_NOEXCEPT {
+      return m_virtualAllocation == rhs.m_virtualAllocation;
+    }
+#endif
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VmaVirtualAllocation() const VULKAN_HPP_NOEXCEPT {
+      return m_virtualAllocation;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+      return m_virtualAllocation != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT {
+      return m_virtualAllocation == VK_NULL_HANDLE;
+    }
+
+  private:
+    VmaVirtualAllocation m_virtualAllocation = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT(sizeof(VirtualAllocation) == sizeof(VmaVirtualAllocation),
+                           "handle and wrapper have different size!");
+}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<VMA_HPP_NAMESPACE::VirtualAllocation, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<VMA_HPP_NAMESPACE::VirtualAllocation, VMA_HPP_NAMESPACE::VirtualBlock>;
+  };
+}
+namespace VMA_HPP_NAMESPACE { using UniqueVirtualAllocation = VULKAN_HPP_NAMESPACE::UniqueHandle<VirtualAllocation, Dispatcher>; }
+#endif
+
+namespace VMA_HPP_NAMESPACE {
+  class VirtualBlock {
+  public:
+    using CType      = VmaVirtualBlock;
+    using NativeType = VmaVirtualBlock;
+  public:
+    VULKAN_HPP_CONSTEXPR         VirtualBlock() = default;
+    VULKAN_HPP_CONSTEXPR         VirtualBlock(std::nullptr_t) VULKAN_HPP_NOEXCEPT {}
+    VULKAN_HPP_TYPESAFE_EXPLICIT VirtualBlock(VmaVirtualBlock virtualBlock) VULKAN_HPP_NOEXCEPT : m_virtualBlock(virtualBlock) {}
+
+#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
+    VirtualBlock& operator=(VmaVirtualBlock virtualBlock) VULKAN_HPP_NOEXCEPT {
+      m_virtualBlock = virtualBlock;
+      return *this;
+    }
+#endif
+
+    VirtualBlock& operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT {
+      m_virtualBlock = {};
+      return *this;
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>(VirtualBlock const &) const = default;
+#else
+    bool operator==(VirtualBlock const & rhs) const VULKAN_HPP_NOEXCEPT {
+      return m_virtualBlock == rhs.m_virtualBlock;
+    }
+#endif
+
+    VULKAN_HPP_TYPESAFE_EXPLICIT operator VmaVirtualBlock() const VULKAN_HPP_NOEXCEPT {
+      return m_virtualBlock;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT {
+      return m_virtualBlock != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT {
+      return m_virtualBlock == VK_NULL_HANDLE;
+    }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void destroy() const;
+#else
+    void destroy() const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NAMESPACE::Bool32 isVirtualBlockEmpty() const;
+#else
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 isVirtualBlockEmpty() const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VirtualAllocationInfo getVirtualAllocationInfo(VirtualAllocation allocation) const;
+#endif
+    void getVirtualAllocationInfo(VirtualAllocation allocation,
+                                  VirtualAllocationInfo* virtualAllocInfo) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<VirtualAllocation>::type virtualAllocate(const VirtualAllocationCreateInfo& createInfo,
+                                                                                                                                    VULKAN_HPP_NAMESPACE::Optional<VULKAN_HPP_NAMESPACE::DeviceSize> offset = nullptr) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniqueVirtualAllocation>::type virtualAllocateUnique(const VirtualAllocationCreateInfo& createInfo,
+                                                                                                                                                VULKAN_HPP_NAMESPACE::Optional<VULKAN_HPP_NAMESPACE::DeviceSize> offset = nullptr) const;
+#endif
+#endif
+    VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result virtualAllocate(const VirtualAllocationCreateInfo* createInfo,
+                                                                      VirtualAllocation* allocation,
+                                                                      VULKAN_HPP_NAMESPACE::DeviceSize* offset) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void virtualFree(VirtualAllocation allocation) const;
+#else
+    void virtualFree(VirtualAllocation allocation) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void clearVirtualBlock() const;
+#else
+    void clearVirtualBlock() const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void setVirtualAllocationUserData(VirtualAllocation allocation,
+                                      void* userData) const;
+#else
+    void setVirtualAllocationUserData(VirtualAllocation allocation,
+                                      void* userData) const;
+#endif
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS Statistics getVirtualBlockStatistics() const;
+#endif
+    void getVirtualBlockStatistics(Statistics* stats) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS DetailedStatistics calculateVirtualBlockStatistics() const;
+#endif
+    void calculateVirtualBlockStatistics(DetailedStatistics* stats) const;
+
+#if VMA_STATS_STRING_ENABLED
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS char* buildVirtualBlockStatsString(VULKAN_HPP_NAMESPACE::Bool32 detailedMap) const;
+#endif
+    void buildVirtualBlockStatsString(char** statsString,
+                                      VULKAN_HPP_NAMESPACE::Bool32 detailedMap) const;
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    void freeVirtualBlockStatsString(char* statsString) const;
+#else
+    void freeVirtualBlockStatsString(char* statsString) const;
+#endif
+
+#endif
+  private:
+    VmaVirtualBlock m_virtualBlock = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT(sizeof(VirtualBlock) == sizeof(VmaVirtualBlock),
+                           "handle and wrapper have different size!");
+}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+namespace VULKAN_HPP_NAMESPACE {
+  template<> struct UniqueHandleTraits<VMA_HPP_NAMESPACE::VirtualBlock, VMA_HPP_NAMESPACE::Dispatcher> {
+    using deleter = VMA_HPP_NAMESPACE::Deleter<VMA_HPP_NAMESPACE::VirtualBlock, void>;
+  };
+}
+namespace VMA_HPP_NAMESPACE { using UniqueVirtualBlock = VULKAN_HPP_NAMESPACE::UniqueHandle<VirtualBlock, Dispatcher>; }
+#endif
+
+namespace VMA_HPP_NAMESPACE {
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<Allocator>::type createAllocator(const AllocatorCreateInfo& createInfo);
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniqueAllocator>::type createAllocatorUnique(const AllocatorCreateInfo& createInfo);
+#endif
+#endif
+  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createAllocator(const AllocatorCreateInfo* createInfo,
+                                                                    Allocator* allocator);
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<VirtualBlock>::type createVirtualBlock(const VirtualBlockCreateInfo& createInfo);
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename VULKAN_HPP_NAMESPACE::ResultValueType<UniqueVirtualBlock>::type createVirtualBlockUnique(const VirtualBlockCreateInfo& createInfo);
+#endif
+#endif
+  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result createVirtualBlock(const VirtualBlockCreateInfo* createInfo,
+                                                                       VirtualBlock* virtualBlock);
+}
+#endif

external/stb/stb_image_implementation.cpp

@@ -0,0 +1,2 @@
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"

external/vulkan-headers

@@ -1 +0,0 @@
-Subproject commit 89d366355e6fe1221c9be40bb2cf3716449e9a7e

external/vulkan-headers/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

external/vulkan-headers/include/vulkan/vk_icd.h

@@ -0,0 +1,262 @@
+//
+// File: vk_icd.h
+//
+/*
+ * Copyright (c) 2015-2016, 2022 The Khronos Group Inc.
+ * Copyright (c) 2015-2016, 2022 Valve Corporation
+ * Copyright (c) 2015-2016, 2022 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef VKICD_H
+#define VKICD_H
+
+#include "vulkan.h"
+#include <stdbool.h>
+
+// Loader-ICD version negotiation API.  Versions add the following features:
+//   Version 0 - Initial.  Doesn't support vk_icdGetInstanceProcAddr
+//               or vk_icdNegotiateLoaderICDInterfaceVersion.
+//   Version 1 - Add support for vk_icdGetInstanceProcAddr.
+//   Version 2 - Add Loader/ICD Interface version negotiation
+//               via vk_icdNegotiateLoaderICDInterfaceVersion.
+//   Version 3 - Add ICD creation/destruction of KHR_surface objects.
+//   Version 4 - Add unknown physical device extension querying via
+//               vk_icdGetPhysicalDeviceProcAddr.
+//   Version 5 - Tells ICDs that the loader is now paying attention to the
+//               application version of Vulkan passed into the ApplicationInfo
+//               structure during vkCreateInstance.  This will tell the ICD
+//               that if the loader is older, it should automatically fail a
+//               call for any API version > 1.0.  Otherwise, the loader will
+//               manually determine if it can support the expected version.
+//   Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices.
+//   Version 7 - If an ICD supports any of the following functions, they must be
+//               queryable with vk_icdGetInstanceProcAddr:
+//                   vk_icdNegotiateLoaderICDInterfaceVersion
+//                   vk_icdGetPhysicalDeviceProcAddr
+//                   vk_icdEnumerateAdapterPhysicalDevices (Windows only)
+//               In addition, these functions no longer need to be exported directly.
+//               This version allows drivers provided through the extension
+//               VK_LUNARG_direct_driver_loading be able to support the entire
+//               Driver-Loader interface.
+
+#define CURRENT_LOADER_ICD_INTERFACE_VERSION 7
+#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
+#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
+
+// Old typedefs that don't follow a proper naming convention but are preserved for compatibility
+typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
+// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
+// file directly, it won't be found.
+#ifndef PFN_GetPhysicalDeviceProcAddr
+typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
+#endif
+
+// Typedefs for loader/ICD interface
+typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID,
+    uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+#endif
+
+// Prototypes for loader/ICD interface
+#if !defined(VK_NO_PROTOTYPES)
+#ifdef __cplusplus
+extern "C" {
+#endif
+    VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion);
+    VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName);
+    VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance isntance, const char* pName);
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID,
+        uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+/*
+ * The ICD must reserve space for a pointer for the loader's dispatch
+ * table, at the start of <each object>.
+ * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
+ */
+
+#define ICD_LOADER_MAGIC 0x01CDC0DE
+
+typedef union {
+    uintptr_t loaderMagic;
+    void *loaderData;
+} VK_LOADER_DATA;
+
+static inline void set_loader_magic_value(void *pNewObject) {
+    VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
+    loader_info->loaderMagic = ICD_LOADER_MAGIC;
+}
+
+static inline bool valid_loader_magic_value(void *pNewObject) {
+    const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
+    return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
+}
+
+/*
+ * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
+ * contains the platform-specific connection and surface information.
+ */
+typedef enum {
+    VK_ICD_WSI_PLATFORM_MIR,
+    VK_ICD_WSI_PLATFORM_WAYLAND,
+    VK_ICD_WSI_PLATFORM_WIN32,
+    VK_ICD_WSI_PLATFORM_XCB,
+    VK_ICD_WSI_PLATFORM_XLIB,
+    VK_ICD_WSI_PLATFORM_ANDROID,
+    VK_ICD_WSI_PLATFORM_MACOS,
+    VK_ICD_WSI_PLATFORM_IOS,
+    VK_ICD_WSI_PLATFORM_DISPLAY,
+    VK_ICD_WSI_PLATFORM_HEADLESS,
+    VK_ICD_WSI_PLATFORM_METAL,
+    VK_ICD_WSI_PLATFORM_DIRECTFB,
+    VK_ICD_WSI_PLATFORM_VI,
+    VK_ICD_WSI_PLATFORM_GGP,
+    VK_ICD_WSI_PLATFORM_SCREEN,
+    VK_ICD_WSI_PLATFORM_FUCHSIA,
+} VkIcdWsiPlatform;
+
+typedef struct {
+    VkIcdWsiPlatform platform;
+} VkIcdSurfaceBase;
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    MirConnection *connection;
+    MirSurface *mirSurface;
+} VkIcdSurfaceMir;
+#endif  // VK_USE_PLATFORM_MIR_KHR
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    struct wl_display *display;
+    struct wl_surface *surface;
+} VkIcdSurfaceWayland;
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    HINSTANCE hinstance;
+    HWND hwnd;
+} VkIcdSurfaceWin32;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    xcb_connection_t *connection;
+    xcb_window_t window;
+} VkIcdSurfaceXcb;
+#endif  // VK_USE_PLATFORM_XCB_KHR
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    Display *dpy;
+    Window window;
+} VkIcdSurfaceXlib;
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+typedef struct {
+    VkIcdSurfaceBase base;
+    IDirectFB *dfb;
+    IDirectFBSurface *surface;
+} VkIcdSurfaceDirectFB;
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+typedef struct {
+    VkIcdSurfaceBase base;
+    struct ANativeWindow *window;
+} VkIcdSurfaceAndroid;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+typedef struct {
+    VkIcdSurfaceBase base;
+    const void *pView;
+} VkIcdSurfaceMacOS;
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+typedef struct {
+    VkIcdSurfaceBase base;
+    const void *pView;
+} VkIcdSurfaceIOS;
+#endif  // VK_USE_PLATFORM_IOS_MVK
+
+#ifdef VK_USE_PLATFORM_GGP
+typedef struct {
+    VkIcdSurfaceBase base;
+    GgpStreamDescriptor streamDescriptor;
+} VkIcdSurfaceGgp;
+#endif  // VK_USE_PLATFORM_GGP
+
+typedef struct {
+    VkIcdSurfaceBase base;
+    VkDisplayModeKHR displayMode;
+    uint32_t planeIndex;
+    uint32_t planeStackIndex;
+    VkSurfaceTransformFlagBitsKHR transform;
+    float globalAlpha;
+    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+    VkExtent2D imageExtent;
+} VkIcdSurfaceDisplay;
+
+typedef struct {
+    VkIcdSurfaceBase base;
+} VkIcdSurfaceHeadless;
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+typedef struct {
+    VkIcdSurfaceBase base;
+    const CAMetalLayer *pLayer;
+} VkIcdSurfaceMetal;
+#endif // VK_USE_PLATFORM_METAL_EXT
+
+#ifdef VK_USE_PLATFORM_VI_NN
+typedef struct {
+    VkIcdSurfaceBase base;
+    void *window;
+} VkIcdSurfaceVi;
+#endif // VK_USE_PLATFORM_VI_NN
+
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+typedef struct {
+    VkIcdSurfaceBase base;
+    struct _screen_context *context;
+    struct _screen_window *window;
+} VkIcdSurfaceScreen;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+typedef struct {
+  VkIcdSurfaceBase base;
+} VkIcdSurfaceImagePipe;
+#endif // VK_USE_PLATFORM_FUCHSIA
+
+#endif  // VKICD_H

external/vulkan-headers/include/vulkan/vk_layer.h

@@ -0,0 +1,211 @@
+//
+// File: vk_layer.h
+//
+/*
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Need to define dispatch table
+ * Core struct can then have ptr to dispatch table at the top
+ * Along with object ptrs for current and next OBJ
+ */
+#pragma once
+
+#include "vulkan_core.h"
+
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define VK_LAYER_EXPORT __attribute__((visibility("default")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define VK_LAYER_EXPORT __attribute__((visibility("default")))
+#else
+#define VK_LAYER_EXPORT
+#endif
+
+#define MAX_NUM_UNKNOWN_EXTS 250
+
+ // Loader-Layer version negotiation API.  Versions add the following features:
+ //   Versions 0/1 - Initial.  Doesn't support vk_layerGetPhysicalDeviceProcAddr
+ //                  or vk_icdNegotiateLoaderLayerInterfaceVersion.
+ //   Version 2    - Add support for vk_layerGetPhysicalDeviceProcAddr and
+ //                  vk_icdNegotiateLoaderLayerInterfaceVersion.
+#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
+#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
+
+#define VK_CURRENT_CHAIN_VERSION 1
+
+// Typedef for use in the interfaces below
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
+
+// Version negotiation values
+typedef enum VkNegotiateLayerStructType {
+    LAYER_NEGOTIATE_UNINTIALIZED = 0,
+    LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
+} VkNegotiateLayerStructType;
+
+// Version negotiation structures
+typedef struct VkNegotiateLayerInterface {
+    VkNegotiateLayerStructType sType;
+    void *pNext;
+    uint32_t loaderLayerInterfaceVersion;
+    PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
+    PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
+} VkNegotiateLayerInterface;
+
+// Version negotiation functions
+typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
+
+// Function prototype for unknown physical device extension command
+typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
+
+// ------------------------------------------------------------------------------------------------
+// CreateInstance and CreateDevice support structures
+
+/* Sub type of structure for instance and device loader ext of CreateInfo.
+ * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
+ * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
+ * then VkLayerFunction indicates struct type pointed to by pNext
+ */
+typedef enum VkLayerFunction_ {
+    VK_LAYER_LINK_INFO = 0,
+    VK_LOADER_DATA_CALLBACK = 1,
+    VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2,
+    VK_LOADER_FEATURES = 3,
+} VkLayerFunction;
+
+typedef struct VkLayerInstanceLink_ {
+    struct VkLayerInstanceLink_ *pNext;
+    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
+    PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
+} VkLayerInstanceLink;
+
+/*
+ * When creating the device chain the loader needs to pass
+ * down information about it's device structure needed at
+ * the end of the chain. Passing the data via the
+ * VkLayerDeviceInfo avoids issues with finding the
+ * exact instance being used.
+ */
+typedef struct VkLayerDeviceInfo_ {
+    void *device_info;
+    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
+} VkLayerDeviceInfo;
+
+typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
+        void *object);
+typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
+        void *object);
+typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
+						      const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
+typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
+
+typedef enum VkLoaderFeastureFlagBits {
+    VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001,
+} VkLoaderFlagBits;
+typedef VkFlags VkLoaderFeatureFlags;
+
+typedef struct {
+    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
+    const void *pNext;
+    VkLayerFunction function;
+    union {
+        VkLayerInstanceLink *pLayerInfo;
+        PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
+        struct {
+	        PFN_vkLayerCreateDevice pfnLayerCreateDevice;
+	        PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
+	    } layerDevice;
+        VkLoaderFeatureFlags loaderFeatures;
+    } u;
+} VkLayerInstanceCreateInfo;
+
+typedef struct VkLayerDeviceLink_ {
+    struct VkLayerDeviceLink_ *pNext;
+    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
+} VkLayerDeviceLink;
+
+typedef struct {
+    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
+    const void *pNext;
+    VkLayerFunction function;
+    union {
+        VkLayerDeviceLink *pLayerInfo;
+        PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
+    } u;
+} VkLayerDeviceCreateInfo;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
+
+typedef enum VkChainType {
+    VK_CHAIN_TYPE_UNKNOWN = 0,
+    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
+    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
+    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
+} VkChainType;
+
+typedef struct VkChainHeader {
+    VkChainType type;
+    uint32_t version;
+    uint32_t size;
+} VkChainHeader;
+
+typedef struct VkEnumerateInstanceExtensionPropertiesChain {
+    VkChainHeader header;
+    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
+                                      VkExtensionProperties *);
+    const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
+
+#if defined(__cplusplus)
+    inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
+        return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
+    }
+#endif
+} VkEnumerateInstanceExtensionPropertiesChain;
+
+typedef struct VkEnumerateInstanceLayerPropertiesChain {
+    VkChainHeader header;
+    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
+    const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
+
+#if defined(__cplusplus)
+    inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
+        return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
+    }
+#endif
+} VkEnumerateInstanceLayerPropertiesChain;
+
+typedef struct VkEnumerateInstanceVersionChain {
+    VkChainHeader header;
+    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
+    const struct VkEnumerateInstanceVersionChain *pNextLink;
+
+#if defined(__cplusplus)
+    inline VkResult CallDown(uint32_t *pApiVersion) const {
+        return pfnNextLayer(pNextLink, pApiVersion);
+    }
+#endif
+} VkEnumerateInstanceVersionChain;
+
+#ifdef __cplusplus
+}
+#endif

external/vulkan-headers/include/vulkan/vk_platform.h

@@ -0,0 +1,84 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright 2014-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+
+#ifndef VK_PLATFORM_H_
+#define VK_PLATFORM_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+    #error "Vulkan is not supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
+    // calling convention, i.e. float parameters are passed in registers. This
+    // is true even if the rest of the application passes floats on the stack,
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#if !defined(VK_NO_STDDEF_H)
+    #include <stddef.h>
+#endif // !defined(VK_NO_STDDEF_H)
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif

external/vulkan-headers/include/vulkan/vk_sdk_platform.h

@@ -0,0 +1,71 @@
+//
+// File: vk_sdk_platform.h
+//
+/*
+ * Copyright (c) 2015-2016 The Khronos Group Inc.
+ * Copyright (c) 2015-2016 Valve Corporation
+ * Copyright (c) 2015-2016 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef VK_SDK_PLATFORM_H
+#define VK_SDK_PLATFORM_H
+
+#if defined(_WIN32)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#ifndef __cplusplus
+#undef inline
+#define inline __inline
+#endif // __cplusplus
+
+#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
+// C99:
+// Microsoft didn't implement C99 in Visual Studio; but started adding it with
+// VS2013.  However, VS2013 still didn't have snprintf().  The following is a
+// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
+// "CMakeLists.txt" file).
+// NOTE: This is fixed in Visual Studio 2015.
+#define snprintf _snprintf
+#endif
+
+#define strdup _strdup
+
+#endif // _WIN32
+
+// Check for noexcept support using clang, with fallback to Windows or GCC version numbers
+#ifndef NOEXCEPT
+#if defined(__clang__)
+#if __has_feature(cxx_noexcept)
+#define HAS_NOEXCEPT
+#endif
+#else
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
+#define HAS_NOEXCEPT
+#else
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
+#define HAS_NOEXCEPT
+#endif
+#endif
+#endif
+
+#ifdef HAS_NOEXCEPT
+#define NOEXCEPT noexcept
+#else
+#define NOEXCEPT
+#endif
+#endif
+
+#endif  // VK_SDK_PLATFORM_H

external/vulkan-headers/include/vulkan/vulkan.h

@@ -0,0 +1,91 @@
+#ifndef VULKAN_H_
+#define VULKAN_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+#include "vk_platform.h"
+#include "vulkan_core.h"
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include "vulkan_android.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+#include <zircon/types.h>
+#include "vulkan_fuchsia.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+#include "vulkan_ios.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+#include "vulkan_macos.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+#include "vulkan_metal.h"
+#endif
+
+#ifdef VK_USE_PLATFORM_VI_NN
+#include "vulkan_vi.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include "vulkan_wayland.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#include "vulkan_win32.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#include "vulkan_xcb.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#include "vulkan_xlib.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+#include <directfb.h>
+#include "vulkan_directfb.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+#include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
+#include "vulkan_xlib_xrandr.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_GGP
+#include <ggp_c/vulkan_types.h>
+#include "vulkan_ggp.h"
+#endif
+
+
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+#include <screen/screen.h>
+#include "vulkan_screen.h"
+#endif
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+#include "vulkan_beta.h"
+#endif
+
+#endif // VULKAN_H_

external/vulkan-headers/include/vulkan/vulkan_android.h

@@ -0,0 +1,125 @@
+#ifndef VULKAN_ANDROID_H_
+#define VULKAN_ANDROID_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_android_surface 1
+struct ANativeWindow;
+#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
+#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+typedef struct VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAndroidSurfaceCreateFlagsKHR    flags;
+    struct ANativeWindow*             window;
+} VkAndroidSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+    VkInstance                                  instance,
+    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_ANDROID_external_memory_android_hardware_buffer 1
+struct AHardwareBuffer;
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 5
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
+typedef struct VkAndroidHardwareBufferUsageANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           androidHardwareBufferUsage;
+} VkAndroidHardwareBufferUsageANDROID;
+
+typedef struct VkAndroidHardwareBufferPropertiesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeBits;
+} VkAndroidHardwareBufferPropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatPropertiesANDROID;
+
+typedef struct VkImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType            sType;
+    const void*                pNext;
+    struct AHardwareBuffer*    buffer;
+} VkImportAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkMemoryGetAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkExternalFormatANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           externalFormat;
+} VkExternalFormatANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags2            formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatProperties2ANDROID;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice                                    device,
+    const struct AHardwareBuffer*               buffer,
+    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice                                    device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    struct AHardwareBuffer**                    pBuffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_beta.h

@@ -0,0 +1,553 @@
+#ifndef VULKAN_BETA_H_
+#define VULKAN_BETA_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_portability_subset 1
+#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1
+#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset"
+typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           constantAlphaColorBlendFactors;
+    VkBool32           events;
+    VkBool32           imageViewFormatReinterpretation;
+    VkBool32           imageViewFormatSwizzle;
+    VkBool32           imageView2DOn3DImage;
+    VkBool32           multisampleArrayImage;
+    VkBool32           mutableComparisonSamplers;
+    VkBool32           pointPolygons;
+    VkBool32           samplerMipLodBias;
+    VkBool32           separateStencilMaskRef;
+    VkBool32           shaderSampleRateInterpolationFunctions;
+    VkBool32           tessellationIsolines;
+    VkBool32           tessellationPointMode;
+    VkBool32           triangleFans;
+    VkBool32           vertexAttributeAccessBeyondStride;
+} VkPhysicalDevicePortabilitySubsetFeaturesKHR;
+
+typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           minVertexInputBindingStrideAlignment;
+} VkPhysicalDevicePortabilitySubsetPropertiesKHR;
+
+
+
+#define VK_KHR_video_encode_queue 1
+#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 7
+#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
+
+typedef enum VkVideoEncodeTuningModeKHR {
+    VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1,
+    VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2,
+    VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3,
+    VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
+    VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeTuningModeKHR;
+typedef VkFlags VkVideoEncodeFlagsKHR;
+
+typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
+    VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
+
+typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeRateControlModeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
+
+typedef enum VkVideoEncodeUsageFlagBitsKHR {
+    VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeUsageFlagBitsKHR;
+typedef VkFlags VkVideoEncodeUsageFlagsKHR;
+
+typedef enum VkVideoEncodeContentFlagBitsKHR {
+    VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeContentFlagBitsKHR;
+typedef VkFlags VkVideoEncodeContentFlagsKHR;
+typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
+typedef struct VkVideoEncodeInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkVideoEncodeFlagsKHR                 flags;
+    uint32_t                              qualityLevel;
+    VkBuffer                              dstBitstreamBuffer;
+    VkDeviceSize                          dstBitstreamBufferOffset;
+    VkDeviceSize                          dstBitstreamBufferMaxRange;
+    VkVideoPictureResourceInfoKHR         srcPictureResource;
+    const VkVideoReferenceSlotInfoKHR*    pSetupReferenceSlot;
+    uint32_t                              referenceSlotCount;
+    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
+    uint32_t                              precedingExternallyEncodedBytes;
+} VkVideoEncodeInfoKHR;
+
+typedef struct VkVideoEncodeCapabilitiesKHR {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkVideoEncodeCapabilityFlagsKHR         flags;
+    VkVideoEncodeRateControlModeFlagsKHR    rateControlModes;
+    uint8_t                                 rateControlLayerCount;
+    uint8_t                                 qualityLevelCount;
+    VkExtent2D                              inputImageDataFillAlignment;
+} VkVideoEncodeCapabilitiesKHR;
+
+typedef struct VkVideoEncodeUsageInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkVideoEncodeUsageFlagsKHR      videoUsageHints;
+    VkVideoEncodeContentFlagsKHR    videoContentHints;
+    VkVideoEncodeTuningModeKHR      tuningMode;
+} VkVideoEncodeUsageInfoKHR;
+
+typedef struct VkVideoEncodeRateControlLayerInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           averageBitrate;
+    uint32_t           maxBitrate;
+    uint32_t           frameRateNumerator;
+    uint32_t           frameRateDenominator;
+    uint32_t           virtualBufferSizeInMs;
+    uint32_t           initialVirtualBufferSizeInMs;
+} VkVideoEncodeRateControlLayerInfoKHR;
+
+typedef struct VkVideoEncodeRateControlInfoKHR {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkVideoEncodeRateControlFlagsKHR               flags;
+    VkVideoEncodeRateControlModeFlagBitsKHR        rateControlMode;
+    uint8_t                                        layerCount;
+    const VkVideoEncodeRateControlLayerInfoKHR*    pLayerConfigs;
+} VkVideoEncodeRateControlInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoEncodeInfoKHR*                 pEncodeInfo);
+#endif
+
+
+#define VK_EXT_video_encode_h264 1
+#include "vk_video/vulkan_video_codec_h264std.h"
+#include "vk_video/vulkan_video_codec_h264std_encode.h"
+#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 9
+#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
+
+typedef enum VkVideoEncodeH264RateControlStructureEXT {
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264RateControlStructureEXT;
+
+typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0x00000008,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000010,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000040,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000080,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000100,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000200,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0x00000400,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0x00000800,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00001000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00002000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00004000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00008000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00010000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00020000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00040000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0x00080000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00100000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0x00200000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00400000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x01000000,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264CapabilityFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
+
+typedef enum VkVideoEncodeH264InputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264InputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264OutputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT;
+typedef struct VkVideoEncodeH264CapabilitiesEXT {
+    VkStructureType                        sType;
+    void*                                  pNext;
+    VkVideoEncodeH264CapabilityFlagsEXT    flags;
+    VkVideoEncodeH264InputModeFlagsEXT     inputModeFlags;
+    VkVideoEncodeH264OutputModeFlagsEXT    outputModeFlags;
+    uint8_t                                maxPPictureL0ReferenceCount;
+    uint8_t                                maxBPictureL0ReferenceCount;
+    uint8_t                                maxL1ReferenceCount;
+    VkBool32                               motionVectorsOverPicBoundariesFlag;
+    uint32_t                               maxBytesPerPicDenom;
+    uint32_t                               maxBitsPerMbDenom;
+    uint32_t                               log2MaxMvLengthHorizontal;
+    uint32_t                               log2MaxMvLengthVertical;
+} VkVideoEncodeH264CapabilitiesEXT;
+
+typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH264SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH264PictureParameterSet*     pStdPPSs;
+} VkVideoEncodeH264SessionParametersAddInfoEXT;
+
+typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
+    const VkVideoEncodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
+} VkVideoEncodeH264SessionParametersCreateInfoEXT;
+
+typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    int8_t                                    slotIndex;
+    const StdVideoEncodeH264ReferenceInfo*    pStdReferenceInfo;
+} VkVideoEncodeH264DpbSlotInfoEXT;
+
+typedef struct VkVideoEncodeH264ReferenceListsInfoEXT {
+    VkStructureType                                      sType;
+    const void*                                          pNext;
+    uint8_t                                              referenceList0EntryCount;
+    const VkVideoEncodeH264DpbSlotInfoEXT*               pReferenceList0Entries;
+    uint8_t                                              referenceList1EntryCount;
+    const VkVideoEncodeH264DpbSlotInfoEXT*               pReferenceList1Entries;
+    const StdVideoEncodeH264RefMemMgmtCtrlOperations*    pMemMgmtCtrlOperations;
+} VkVideoEncodeH264ReferenceListsInfoEXT;
+
+typedef struct VkVideoEncodeH264NaluSliceInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    uint32_t                                         mbCount;
+    const VkVideoEncodeH264ReferenceListsInfoEXT*    pReferenceFinalLists;
+    const StdVideoEncodeH264SliceHeader*             pSliceHeaderStd;
+} VkVideoEncodeH264NaluSliceInfoEXT;
+
+typedef struct VkVideoEncodeH264VclFrameInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    const VkVideoEncodeH264ReferenceListsInfoEXT*    pReferenceFinalLists;
+    uint32_t                                         naluSliceEntryCount;
+    const VkVideoEncodeH264NaluSliceInfoEXT*         pNaluSliceEntries;
+    const StdVideoEncodeH264PictureInfo*             pCurrentPictureInfo;
+} VkVideoEncodeH264VclFrameInfoEXT;
+
+typedef struct VkVideoEncodeH264EmitPictureParametersInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint8_t            spsId;
+    VkBool32           emitSpsEnable;
+    uint32_t           ppsIdEntryCount;
+    const uint8_t*     ppsIdEntries;
+} VkVideoEncodeH264EmitPictureParametersInfoEXT;
+
+typedef struct VkVideoEncodeH264ProfileInfoEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH264ProfileIdc    stdProfileIdc;
+} VkVideoEncodeH264ProfileInfoEXT;
+
+typedef struct VkVideoEncodeH264RateControlInfoEXT {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    gopFrameCount;
+    uint32_t                                    idrPeriod;
+    uint32_t                                    consecutiveBFrameCount;
+    VkVideoEncodeH264RateControlStructureEXT    rateControlStructure;
+    uint8_t                                     temporalLayerCount;
+} VkVideoEncodeH264RateControlInfoEXT;
+
+typedef struct VkVideoEncodeH264QpEXT {
+    int32_t    qpI;
+    int32_t    qpP;
+    int32_t    qpB;
+} VkVideoEncodeH264QpEXT;
+
+typedef struct VkVideoEncodeH264FrameSizeEXT {
+    uint32_t    frameISize;
+    uint32_t    framePSize;
+    uint32_t    frameBSize;
+} VkVideoEncodeH264FrameSizeEXT;
+
+typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    uint8_t                          temporalLayerId;
+    VkBool32                         useInitialRcQp;
+    VkVideoEncodeH264QpEXT           initialRcQp;
+    VkBool32                         useMinQp;
+    VkVideoEncodeH264QpEXT           minQp;
+    VkBool32                         useMaxQp;
+    VkVideoEncodeH264QpEXT           maxQp;
+    VkBool32                         useMaxFrameSize;
+    VkVideoEncodeH264FrameSizeEXT    maxFrameSize;
+} VkVideoEncodeH264RateControlLayerInfoEXT;
+
+
+
+#define VK_EXT_video_encode_h265 1
+#include "vk_video/vulkan_video_codec_h265std.h"
+#include "vk_video/vulkan_video_codec_h265std_encode.h"
+#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 9
+#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
+
+typedef enum VkVideoEncodeH265RateControlStructureEXT {
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265RateControlStructureEXT;
+
+typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0x00000008,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0x00000010,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0x00000040,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265CapabilityFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
+
+typedef enum VkVideoEncodeH265InputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265InputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265InputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH265OutputModeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265OutputModeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265OutputModeFlagsEXT;
+
+typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265CtbSizeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT;
+
+typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT {
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT;
+typedef struct VkVideoEncodeH265CapabilitiesEXT {
+    VkStructureType                                sType;
+    void*                                          pNext;
+    VkVideoEncodeH265CapabilityFlagsEXT            flags;
+    VkVideoEncodeH265InputModeFlagsEXT             inputModeFlags;
+    VkVideoEncodeH265OutputModeFlagsEXT            outputModeFlags;
+    VkVideoEncodeH265CtbSizeFlagsEXT               ctbSizes;
+    VkVideoEncodeH265TransformBlockSizeFlagsEXT    transformBlockSizes;
+    uint8_t                                        maxPPictureL0ReferenceCount;
+    uint8_t                                        maxBPictureL0ReferenceCount;
+    uint8_t                                        maxL1ReferenceCount;
+    uint8_t                                        maxSubLayersCount;
+    uint8_t                                        minLog2MinLumaCodingBlockSizeMinus3;
+    uint8_t                                        maxLog2MinLumaCodingBlockSizeMinus3;
+    uint8_t                                        minLog2MinLumaTransformBlockSizeMinus2;
+    uint8_t                                        maxLog2MinLumaTransformBlockSizeMinus2;
+    uint8_t                                        minMaxTransformHierarchyDepthInter;
+    uint8_t                                        maxMaxTransformHierarchyDepthInter;
+    uint8_t                                        minMaxTransformHierarchyDepthIntra;
+    uint8_t                                        maxMaxTransformHierarchyDepthIntra;
+    uint8_t                                        maxDiffCuQpDeltaDepth;
+    uint8_t                                        minMaxNumMergeCand;
+    uint8_t                                        maxMaxNumMergeCand;
+} VkVideoEncodeH265CapabilitiesEXT;
+
+typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   stdVPSCount;
+    const StdVideoH265VideoParameterSet*       pStdVPSs;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH265SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH265PictureParameterSet*     pStdPPSs;
+} VkVideoEncodeH265SessionParametersAddInfoEXT;
+
+typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxStdVPSCount;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
+    const VkVideoEncodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
+} VkVideoEncodeH265SessionParametersCreateInfoEXT;
+
+typedef struct VkVideoEncodeH265DpbSlotInfoEXT {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    int8_t                                    slotIndex;
+    const StdVideoEncodeH265ReferenceInfo*    pStdReferenceInfo;
+} VkVideoEncodeH265DpbSlotInfoEXT;
+
+typedef struct VkVideoEncodeH265ReferenceListsInfoEXT {
+    VkStructureType                                    sType;
+    const void*                                        pNext;
+    uint8_t                                            referenceList0EntryCount;
+    const VkVideoEncodeH265DpbSlotInfoEXT*             pReferenceList0Entries;
+    uint8_t                                            referenceList1EntryCount;
+    const VkVideoEncodeH265DpbSlotInfoEXT*             pReferenceList1Entries;
+    const StdVideoEncodeH265ReferenceModifications*    pReferenceModifications;
+} VkVideoEncodeH265ReferenceListsInfoEXT;
+
+typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    uint32_t                                         ctbCount;
+    const VkVideoEncodeH265ReferenceListsInfoEXT*    pReferenceFinalLists;
+    const StdVideoEncodeH265SliceSegmentHeader*      pSliceSegmentHeaderStd;
+} VkVideoEncodeH265NaluSliceSegmentInfoEXT;
+
+typedef struct VkVideoEncodeH265VclFrameInfoEXT {
+    VkStructureType                                    sType;
+    const void*                                        pNext;
+    const VkVideoEncodeH265ReferenceListsInfoEXT*      pReferenceFinalLists;
+    uint32_t                                           naluSliceSegmentEntryCount;
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT*    pNaluSliceSegmentEntries;
+    const StdVideoEncodeH265PictureInfo*               pCurrentPictureInfo;
+} VkVideoEncodeH265VclFrameInfoEXT;
+
+typedef struct VkVideoEncodeH265EmitPictureParametersInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint8_t            vpsId;
+    uint8_t            spsId;
+    VkBool32           emitVpsEnable;
+    VkBool32           emitSpsEnable;
+    uint32_t           ppsIdEntryCount;
+    const uint8_t*     ppsIdEntries;
+} VkVideoEncodeH265EmitPictureParametersInfoEXT;
+
+typedef struct VkVideoEncodeH265ProfileInfoEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH265ProfileIdc    stdProfileIdc;
+} VkVideoEncodeH265ProfileInfoEXT;
+
+typedef struct VkVideoEncodeH265RateControlInfoEXT {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    gopFrameCount;
+    uint32_t                                    idrPeriod;
+    uint32_t                                    consecutiveBFrameCount;
+    VkVideoEncodeH265RateControlStructureEXT    rateControlStructure;
+    uint8_t                                     subLayerCount;
+} VkVideoEncodeH265RateControlInfoEXT;
+
+typedef struct VkVideoEncodeH265QpEXT {
+    int32_t    qpI;
+    int32_t    qpP;
+    int32_t    qpB;
+} VkVideoEncodeH265QpEXT;
+
+typedef struct VkVideoEncodeH265FrameSizeEXT {
+    uint32_t    frameISize;
+    uint32_t    framePSize;
+    uint32_t    frameBSize;
+} VkVideoEncodeH265FrameSizeEXT;
+
+typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    uint8_t                          temporalId;
+    VkBool32                         useInitialRcQp;
+    VkVideoEncodeH265QpEXT           initialRcQp;
+    VkBool32                         useMinQp;
+    VkVideoEncodeH265QpEXT           minQp;
+    VkBool32                         useMaxQp;
+    VkVideoEncodeH265QpEXT           maxQp;
+    VkBool32                         useMaxFrameSize;
+    VkVideoEncodeH265FrameSizeEXT    maxFrameSize;
+} VkVideoEncodeH265RateControlLayerInfoEXT;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_directfb.h

@@ -0,0 +1,54 @@
+#ifndef VULKAN_DIRECTFB_H_
+#define VULKAN_DIRECTFB_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_EXT_directfb_surface 1
+#define VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION 1
+#define VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME "VK_EXT_directfb_surface"
+typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT;
+typedef struct VkDirectFBSurfaceCreateInfoEXT {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkDirectFBSurfaceCreateFlagsEXT    flags;
+    IDirectFB*                         dfb;
+    IDirectFBSurface*                  surface;
+} VkDirectFBSurfaceCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(
+    VkInstance                                  instance,
+    const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    IDirectFB*                                  dfb);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_fuchsia.h

@@ -0,0 +1,258 @@
+#ifndef VULKAN_FUCHSIA_H_
+#define VULKAN_FUCHSIA_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_FUCHSIA_imagepipe_surface 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
+#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
+typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
+typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
+    zx_handle_t                             imagePipeHandle;
+} VkImagePipeSurfaceCreateInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
+    VkInstance                                  instance,
+    const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_FUCHSIA_external_memory 1
+#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory"
+typedef struct VkImportMemoryZirconHandleInfoFUCHSIA {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    zx_handle_t                           handle;
+} VkImportMemoryZirconHandleInfoFUCHSIA;
+
+typedef struct VkMemoryZirconHandlePropertiesFUCHSIA {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryZirconHandlePropertiesFUCHSIA;
+
+typedef struct VkMemoryGetZirconHandleInfoFUCHSIA {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetZirconHandleInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(
+    VkDevice                                    device,
+    const VkMemoryGetZirconHandleInfoFUCHSIA*   pGetZirconHandleInfo,
+    zx_handle_t*                                pZirconHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    zx_handle_t                                 zirconHandle,
+    VkMemoryZirconHandlePropertiesFUCHSIA*      pMemoryZirconHandleProperties);
+#endif
+
+
+#define VK_FUCHSIA_external_semaphore 1
+#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
+#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore"
+typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    zx_handle_t                              zirconHandle;
+} VkImportSemaphoreZirconHandleInfoFUCHSIA;
+
+typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetZirconHandleInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(
+    VkDevice                                    device,
+    const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
+    VkDevice                                    device,
+    const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+    zx_handle_t*                                pZirconHandle);
+#endif
+
+
+#define VK_FUCHSIA_buffer_collection 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA)
+#define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 2
+#define VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME "VK_FUCHSIA_buffer_collection"
+typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA;
+
+typedef enum VkImageConstraintsInfoFlagBitsFUCHSIA {
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004,
+    VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008,
+    VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010,
+    VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF
+} VkImageConstraintsInfoFlagBitsFUCHSIA;
+typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA;
+typedef struct VkBufferCollectionCreateInfoFUCHSIA {
+    VkStructureType    sType;
+    const void*        pNext;
+    zx_handle_t        collectionToken;
+} VkBufferCollectionCreateInfoFUCHSIA;
+
+typedef struct VkImportMemoryBufferCollectionFUCHSIA {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkBufferCollectionFUCHSIA    collection;
+    uint32_t                     index;
+} VkImportMemoryBufferCollectionFUCHSIA;
+
+typedef struct VkBufferCollectionImageCreateInfoFUCHSIA {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkBufferCollectionFUCHSIA    collection;
+    uint32_t                     index;
+} VkBufferCollectionImageCreateInfoFUCHSIA;
+
+typedef struct VkBufferCollectionConstraintsInfoFUCHSIA {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           minBufferCount;
+    uint32_t           maxBufferCount;
+    uint32_t           minBufferCountForCamping;
+    uint32_t           minBufferCountForDedicatedSlack;
+    uint32_t           minBufferCountForSharedSlack;
+} VkBufferCollectionConstraintsInfoFUCHSIA;
+
+typedef struct VkBufferConstraintsInfoFUCHSIA {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkBufferCreateInfo                          createInfo;
+    VkFormatFeatureFlags                        requiredFormatFeatures;
+    VkBufferCollectionConstraintsInfoFUCHSIA    bufferCollectionConstraints;
+} VkBufferConstraintsInfoFUCHSIA;
+
+typedef struct VkBufferCollectionBufferCreateInfoFUCHSIA {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkBufferCollectionFUCHSIA    collection;
+    uint32_t                     index;
+} VkBufferCollectionBufferCreateInfoFUCHSIA;
+
+typedef struct VkSysmemColorSpaceFUCHSIA {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorSpace;
+} VkSysmemColorSpaceFUCHSIA;
+
+typedef struct VkBufferCollectionPropertiesFUCHSIA {
+    VkStructureType                  sType;
+    void*                            pNext;
+    uint32_t                         memoryTypeBits;
+    uint32_t                         bufferCount;
+    uint32_t                         createInfoIndex;
+    uint64_t                         sysmemPixelFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkSysmemColorSpaceFUCHSIA        sysmemColorSpaceIndex;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkBufferCollectionPropertiesFUCHSIA;
+
+typedef struct VkImageFormatConstraintsInfoFUCHSIA {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkImageCreateInfo                       imageCreateInfo;
+    VkFormatFeatureFlags                    requiredFormatFeatures;
+    VkImageFormatConstraintsFlagsFUCHSIA    flags;
+    uint64_t                                sysmemPixelFormat;
+    uint32_t                                colorSpaceCount;
+    const VkSysmemColorSpaceFUCHSIA*        pColorSpaces;
+} VkImageFormatConstraintsInfoFUCHSIA;
+
+typedef struct VkImageConstraintsInfoFUCHSIA {
+    VkStructureType                               sType;
+    const void*                                   pNext;
+    uint32_t                                      formatConstraintsCount;
+    const VkImageFormatConstraintsInfoFUCHSIA*    pFormatConstraints;
+    VkBufferCollectionConstraintsInfoFUCHSIA      bufferCollectionConstraints;
+    VkImageConstraintsInfoFlagsFUCHSIA            flags;
+} VkImageConstraintsInfoFUCHSIA;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
+typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(
+    VkDevice                                    device,
+    const VkBufferCollectionCreateInfoFUCHSIA*  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBufferCollectionFUCHSIA*                  pCollection);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    const VkImageConstraintsInfoFUCHSIA*        pImageConstraintsInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    const VkBufferConstraintsInfoFUCHSIA*       pBufferConstraintsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(
+    VkDevice                                    device,
+    VkBufferCollectionFUCHSIA                   collection,
+    VkBufferCollectionPropertiesFUCHSIA*        pProperties);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_ggp.h

@@ -0,0 +1,58 @@
+#ifndef VULKAN_GGP_H_
+#define VULKAN_GGP_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_GGP_stream_descriptor_surface 1
+#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
+#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface"
+typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP;
+typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkStreamDescriptorSurfaceCreateFlagsGGP    flags;
+    GgpStreamDescriptor                        streamDescriptor;
+} VkStreamDescriptorSurfaceCreateInfoGGP;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
+    VkInstance                                  instance,
+    const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_GGP_frame_token 1
+#define VK_GGP_FRAME_TOKEN_SPEC_VERSION   1
+#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token"
+typedef struct VkPresentFrameTokenGGP {
+    VkStructureType    sType;
+    const void*        pNext;
+    GgpFrameToken      frameToken;
+} VkPresentFrameTokenGGP;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_ios.h

@@ -0,0 +1,47 @@
+#ifndef VULKAN_IOS_H_
+#define VULKAN_IOS_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_MVK_ios_surface 1
+#define VK_MVK_IOS_SURFACE_SPEC_VERSION   3
+#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
+typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+typedef struct VkIOSSurfaceCreateInfoMVK {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkIOSSurfaceCreateFlagsMVK    flags;
+    const void*                   pView;
+} VkIOSSurfaceCreateInfoMVK;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_macos.h

@@ -0,0 +1,47 @@
+#ifndef VULKAN_MACOS_H_
+#define VULKAN_MACOS_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_MVK_macos_surface 1
+#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3
+#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+typedef struct VkMacOSSurfaceCreateInfoMVK {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_metal.h

@@ -0,0 +1,193 @@
+#ifndef VULKAN_METAL_H_
+#define VULKAN_METAL_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_EXT_metal_surface 1
+#ifdef __OBJC__
+@class CAMetalLayer;
+#else
+typedef void CAMetalLayer;
+#endif
+
+#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1
+#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
+typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
+typedef struct VkMetalSurfaceCreateInfoEXT {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMetalSurfaceCreateFlagsEXT    flags;
+    const CAMetalLayer*             pLayer;
+} VkMetalSurfaceCreateInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
+    VkInstance                                  instance,
+    const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+
+#define VK_EXT_metal_objects 1
+#ifdef __OBJC__
+@protocol MTLDevice;
+typedef id<MTLDevice> MTLDevice_id;
+#else
+typedef void* MTLDevice_id;
+#endif
+
+#ifdef __OBJC__
+@protocol MTLCommandQueue;
+typedef id<MTLCommandQueue> MTLCommandQueue_id;
+#else
+typedef void* MTLCommandQueue_id;
+#endif
+
+#ifdef __OBJC__
+@protocol MTLBuffer;
+typedef id<MTLBuffer> MTLBuffer_id;
+#else
+typedef void* MTLBuffer_id;
+#endif
+
+#ifdef __OBJC__
+@protocol MTLTexture;
+typedef id<MTLTexture> MTLTexture_id;
+#else
+typedef void* MTLTexture_id;
+#endif
+
+typedef struct __IOSurface* IOSurfaceRef;
+#ifdef __OBJC__
+@protocol MTLSharedEvent;
+typedef id<MTLSharedEvent> MTLSharedEvent_id;
+#else
+typedef void* MTLSharedEvent_id;
+#endif
+
+#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
+#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
+
+typedef enum VkExportMetalObjectTypeFlagBitsEXT {
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010,
+    VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020,
+    VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkExportMetalObjectTypeFlagBitsEXT;
+typedef VkFlags VkExportMetalObjectTypeFlagsEXT;
+typedef struct VkExportMetalObjectCreateInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExportMetalObjectTypeFlagBitsEXT    exportObjectType;
+} VkExportMetalObjectCreateInfoEXT;
+
+typedef struct VkExportMetalObjectsInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkExportMetalObjectsInfoEXT;
+
+typedef struct VkExportMetalDeviceInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    MTLDevice_id       mtlDevice;
+} VkExportMetalDeviceInfoEXT;
+
+typedef struct VkExportMetalCommandQueueInfoEXT {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkQueue               queue;
+    MTLCommandQueue_id    mtlCommandQueue;
+} VkExportMetalCommandQueueInfoEXT;
+
+typedef struct VkExportMetalBufferInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+    MTLBuffer_id       mtlBuffer;
+} VkExportMetalBufferInfoEXT;
+
+typedef struct VkImportMetalBufferInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    MTLBuffer_id       mtlBuffer;
+} VkImportMetalBufferInfoEXT;
+
+typedef struct VkExportMetalTextureInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImage                  image;
+    VkImageView              imageView;
+    VkBufferView             bufferView;
+    VkImageAspectFlagBits    plane;
+    MTLTexture_id            mtlTexture;
+} VkExportMetalTextureInfoEXT;
+
+typedef struct VkImportMetalTextureInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageAspectFlagBits    plane;
+    MTLTexture_id            mtlTexture;
+} VkImportMetalTextureInfoEXT;
+
+typedef struct VkExportMetalIOSurfaceInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    IOSurfaceRef       ioSurface;
+} VkExportMetalIOSurfaceInfoEXT;
+
+typedef struct VkImportMetalIOSurfaceInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    IOSurfaceRef       ioSurface;
+} VkImportMetalIOSurfaceInfoEXT;
+
+typedef struct VkExportMetalSharedEventInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkSemaphore          semaphore;
+    VkEvent              event;
+    MTLSharedEvent_id    mtlSharedEvent;
+} VkExportMetalSharedEventInfoEXT;
+
+typedef struct VkImportMetalSharedEventInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    MTLSharedEvent_id    mtlSharedEvent;
+} VkImportMetalSharedEventInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
+    VkDevice                                    device,
+    VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_screen.h

@@ -0,0 +1,54 @@
+#ifndef VULKAN_SCREEN_H_
+#define VULKAN_SCREEN_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_QNX_screen_surface 1
+#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1
+#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface"
+typedef VkFlags VkScreenSurfaceCreateFlagsQNX;
+typedef struct VkScreenSurfaceCreateInfoQNX {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkScreenSurfaceCreateFlagsQNX    flags;
+    struct _screen_context*          context;
+    struct _screen_window*           window;
+} VkScreenSurfaceCreateInfoQNX;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(
+    VkInstance                                  instance,
+    const VkScreenSurfaceCreateInfoQNX*         pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct _screen_window*                      window);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_vi.h

@@ -0,0 +1,47 @@
+#ifndef VULKAN_VI_H_
+#define VULKAN_VI_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_NN_vi_surface 1
+#define VK_NN_VI_SURFACE_SPEC_VERSION     1
+#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
+typedef VkFlags VkViSurfaceCreateFlagsNN;
+typedef struct VkViSurfaceCreateInfoNN {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkViSurfaceCreateFlagsNN    flags;
+    void*                       window;
+} VkViSurfaceCreateInfoNN;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
+    VkInstance                                  instance,
+    const VkViSurfaceCreateInfoNN*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_wayland.h

@@ -0,0 +1,54 @@
+#ifndef VULKAN_WAYLAND_H_
+#define VULKAN_WAYLAND_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_wayland_surface 1
+#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+typedef struct VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkWaylandSurfaceCreateFlagsKHR    flags;
+    struct wl_display*                display;
+    struct wl_surface*                surface;
+} VkWaylandSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+    VkInstance                                  instance,
+    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct wl_display*                          display);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_win32.h

@@ -0,0 +1,333 @@
+#ifndef VULKAN_WIN32_H_
+#define VULKAN_WIN32_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_win32_surface 1
+#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+typedef struct VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkWin32SurfaceCreateFlagsKHR    flags;
+    HINSTANCE                       hinstance;
+    HWND                            hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+    VkInstance                                  instance,
+    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex);
+#endif
+
+
+#define VK_KHR_external_memory_win32 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
+typedef struct VkImportMemoryWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    HANDLE                                handle;
+    LPCWSTR                               name;
+} VkImportMemoryWin32HandleInfoKHR;
+
+typedef struct VkExportMemoryWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportMemoryWin32HandleInfoKHR;
+
+typedef struct VkMemoryWin32HandlePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryWin32HandlePropertiesKHR;
+
+typedef struct VkMemoryGetWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetWin32HandleInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
+    VkDevice                                    device,
+    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    HANDLE                                      handle,
+    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
+#endif
+
+
+#define VK_KHR_win32_keyed_mutex 1
+#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeouts;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_win32 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
+typedef struct VkImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    HANDLE                                   handle;
+    LPCWSTR                                  name;
+} VkImportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkD3D12FenceSubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreValuesCount;
+    const uint64_t*    pWaitSemaphoreValues;
+    uint32_t           signalSemaphoreValuesCount;
+    const uint64_t*    pSignalSemaphoreValues;
+} VkD3D12FenceSubmitInfoKHR;
+
+typedef struct VkSemaphoreGetWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetWin32HandleInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+
+#define VK_KHR_external_fence_win32 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
+typedef struct VkImportFenceWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    HANDLE                               handle;
+    LPCWSTR                              name;
+} VkImportFenceWin32HandleInfoKHR;
+
+typedef struct VkExportFenceWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportFenceWin32HandleInfoKHR;
+
+typedef struct VkFenceGetWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetWin32HandleInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+
+#define VK_NV_external_memory_win32 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
+typedef struct VkImportMemoryWin32HandleInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleType;
+    HANDLE                               handle;
+} VkImportMemoryWin32HandleInfoNV;
+
+typedef struct VkExportMemoryWin32HandleInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+} VkExportMemoryWin32HandleInfoNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkExternalMemoryHandleTypeFlagsNV           handleType,
+    HANDLE*                                     pHandle);
+#endif
+
+
+#define VK_NV_win32_keyed_mutex 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
+#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeoutMilliseconds;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoNV;
+
+
+
+#define VK_EXT_full_screen_exclusive 1
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
+
+typedef enum VkFullScreenExclusiveEXT {
+    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
+    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
+    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
+    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
+    VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkFullScreenExclusiveEXT;
+typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkFullScreenExclusiveEXT    fullScreenExclusive;
+} VkSurfaceFullScreenExclusiveInfoEXT;
+
+typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           fullScreenExclusiveSupported;
+} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
+
+typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    HMONITOR           hmonitor;
+} VkSurfaceFullScreenExclusiveWin32InfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
+typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    uint32_t*                                   pPresentModeCount,
+    VkPresentModeKHR*                           pPresentModes);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
+    VkDevice                                    device,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    VkDeviceGroupPresentModeFlagsKHR*           pModes);
+#endif
+
+
+#define VK_NV_acquire_winrt_display 1
+#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
+#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    deviceRelativeId,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_xcb.h

@@ -0,0 +1,55 @@
+#ifndef VULKAN_XCB_H_
+#define VULKAN_XCB_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_xcb_surface 1
+#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
+#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+typedef struct VkXcbSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkXcbSurfaceCreateFlagsKHR    flags;
+    xcb_connection_t*             connection;
+    xcb_window_t                  window;
+} VkXcbSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    xcb_connection_t*                           connection,
+    xcb_visualid_t                              visual_id);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_xlib.h

@@ -0,0 +1,55 @@
+#ifndef VULKAN_XLIB_H_
+#define VULKAN_XLIB_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_KHR_xlib_surface 1
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
+#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+typedef struct VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkXlibSurfaceCreateFlagsKHR    flags;
+    Display*                       dpy;
+    Window                         window;
+} VkXlibSurfaceCreateInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    Display*                                    dpy,
+    VisualID                                    visualID);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

external/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h

@@ -0,0 +1,45 @@
+#ifndef VULKAN_XLIB_XRANDR_H_
+#define VULKAN_XLIB_XRANDR_H_ 1
+
+/*
+** Copyright 2015-2022 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define VK_EXT_acquire_xlib_display 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    RROutput                                    rrOutput,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

fscompat.cpp

@@ -78,9 +78,19 @@ SplitPath splitpath(string str)
 
 string makepath(const string &drive, const string &dir, const string &stem, const string &ext)
 {
+    auto dot_position = ext.find('.');
+
+    if (dot_position == string::npos)
+    {
+        fs::path path(drive);
+        path = path / dir / stem;
+        path.replace_extension(ext);
+        return path.string();
+    }
+
+    auto filename = stem + ext;
     fs::path path(drive);
-    path = path / dir / stem;
-    path.replace_extension(ext);
+    path = path / dir / filename;
     return path.string();
 }
 
@@ -123,7 +133,7 @@ SplitPath splitpath(string path)
     return output;
 }
 
-string makepath(string drive, string dir, string stem, string ext)
+string makepath(const string &drive, const string &dir, const string &stem, const string &ext)
 {
     string output;
 
@@ -148,7 +158,7 @@ string makepath(string drive, string dir, string stem, string ext)
 
     if (!ext.empty())
     {
-        if (ext[0] != '.')
+        if (ext.find('.') == string::npos)
             output += '.';
         output += ext;
     }
@@ -215,7 +225,7 @@ void _makepath(char *path, const char *drive, const char *dir, const char *fname
 
     if (ext && *ext)
     {
-        if (*ext != '.')
+        if (!strchr(ext, '.'))
             strcat(path, ".");
         strcat(path, ext);
     }

gtk/CMakeLists.txt

@@ -36,7 +36,7 @@ add_compile_definitions(HAVE_LIBPNG
                         SNES9XLOCALEDIR=\"${LOCALEDIR}\")
 set(INCLUDES ../apu/bapu ../ src)
 set(SOURCES)
-set(ARGS -Wall -W -Wno-unused-parameter)
+set(ARGS -Wall -Wno-unused-parameter)
 set(LIBS)
 set(DEFINES)
 
@@ -85,6 +85,39 @@ if(USE_SLANG)
                      spirv-cross-cpp)
     list(APPEND DEFINES "USE_SLANG")
     list(APPEND INCLUDES "../external/glslang")
+
+    list(APPEND DEFINES "VK_USE_PLATFORM_XLIB_KHR"
+                        "VK_USE_PLATFORM_WAYLAND_KHR"
+                        "VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1"
+                        "VMA_DYNAMIC_VULKAN_FUNCTIONS=1"
+                        "VMA_STATIC_VULKAN_FUNCTIONS=0")
+    list(APPEND INCLUDES ../external/vulkan-headers/include)
+    list(APPEND INCLUDES ../external/VulkanMemoryAllocator-Hpp/include)
+    list(APPEND INCLUDES ../external/stb)
+    list(APPEND SOURCES ../external/stb/stb_image_implementation.cpp)
+    list(APPEND SOURCES ../vulkan/slang_helpers.cpp
+                        ../vulkan/slang_helpers.hpp
+                        ../vulkan/slang_shader.cpp
+                        ../vulkan/slang_shader.hpp
+                        ../vulkan/slang_preset.cpp
+                        ../vulkan/slang_preset.hpp
+                        ../vulkan/slang_preset_ini.cpp
+                        ../vulkan/slang_preset_ini.hpp
+                        ../vulkan/vulkan_hpp_storage.cpp
+                        ../vulkan/vk_mem_alloc_implementation.cpp
+                        ../vulkan/vulkan_context.cpp
+                        ../vulkan/vulkan_context.hpp
+                        ../vulkan/vulkan_texture.cpp
+                        ../vulkan/vulkan_texture.hpp
+                        ../vulkan/vulkan_swapchain.cpp
+                        ../vulkan/vulkan_swapchain.hpp
+                        ../vulkan/vulkan_slang_pipeline.cpp
+                        ../vulkan/vulkan_slang_pipeline.hpp
+                        ../vulkan/vulkan_pipeline_image.cpp
+                        ../vulkan/vulkan_pipeline_image.hpp
+                        ../vulkan/vulkan_shader_chain.cpp
+                        ../vulkan/vulkan_shader_chain.hpp)
+
 endif()
 
 if(USE_WAYLAND)
@@ -189,6 +222,8 @@ list(APPEND SOURCES
     src/gtk_control.h
     src/gtk_display.cpp
     src/gtk_display_driver_gtk.cpp
+    src/gtk_display_driver_vulkan.cpp
+    src/gtk_display_driver_vulkan.h
     src/gtk_display_driver_gtk.h
     src/gtk_display_driver.h
     src/gtk_display.h
@@ -318,6 +353,39 @@ target_compile_options(snes9x-gtk PRIVATE ${ARGS})
 target_link_libraries(snes9x-gtk PRIVATE ${LIBS})
 target_compile_definitions(snes9x-gtk PRIVATE ${DEFINES})
 
+add_executable(slang_test ../vulkan/slang_helpers.cpp
+                        ../vulkan/slang_helpers.hpp
+                        ../vulkan/slang_shader.cpp
+                        ../vulkan/slang_shader.hpp
+                        ../vulkan/slang_preset.cpp
+                        ../vulkan/slang_preset.hpp
+                        ../vulkan/slang_preset_ini.cpp
+                        ../vulkan/slang_preset_ini.hpp
+                        ../vulkan/vulkan_hpp_storage.cpp
+                        ../vulkan/slang_preset_test.cpp
+                        ../conffile.cpp
+                        ../stream.cpp)
+#add_executable(vulkan_test ../vulkan/slang_helpers.cpp
+#                           ../vulkan/slang_helpers.hpp
+#                           ../vulkan/slang_shader.cpp
+#                           ../vulkan/slang_shader.hpp
+#                           ../vulkan/slang_preset.cpp
+#                          ../vulkan/slang_preset.hpp
+#                           ../vulkan/vulkan_hpp_storage.cpp
+#                           ../vulkan/test.cpp
+#                           ../vulkan/vk2d.cpp
+#                           ../conffile.cpp
+#                           ../stream.cpp)
+#target_include_directories(vulkan_test PRIVATE ${INCLUDES})
+#target_compile_options(vulkan_test PRIVATE ${ARGS})
+#target_compile_definitions(vulkan_test PRIVATE ${DEFINES} "VULKAN_HPP_NO_EXCEPTIONS" "VULKAN_HPP_ASSERT_ON_RESULT=")
+#target_link_libraries(vulkan_test PRIVATE ${LIBS})
+
+target_include_directories(slang_test PRIVATE ${INCLUDES})
+target_compile_options(slang_test PRIVATE ${ARGS})
+target_compile_definitions(slang_test PRIVATE ${DEFINES})
+target_link_libraries(slang_test PRIVATE ${LIBS})
+
 install(TARGETS snes9x-gtk)
 install(FILES ../data/cheats.bml DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${CMAKE_INSTALL_DATADIR})
 install(FILES data/snes9x-gtk.desktop DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/applications)

gtk/src/filter_epx_unsafe.cpp

@@ -4,13 +4,6 @@
    For further information, consult the LICENSE file in the root directory.
 \*****************************************************************************/
 
-#include "snes9x.h"
-#include "memmap.h"
-#include "cpuops.h"
-#include "dma.h"
-#include "apu/apu.h"
-#include "fxemu.h"
-#include "snapshot.h"
 #ifdef DEBUGGER
 #include "debug.h"
 #include "missing.h"

gtk/src/gtk_config.cpp

@@ -13,7 +13,6 @@
 #include "fmt/format.h"
 #include "gtk_config.h"
 #include "gtk_s9x.h"
-#include "gtk_sound.h"
 #include "gtk_display.h"
 #include "conffile.h"
 #include "cheats.h"
@@ -82,7 +81,7 @@ int Snes9xConfig::load_defaults()
     rom_loaded = false;
     multithreading = false;
     splash_image = SPLASH_IMAGE_STARFIELD;
-    display_driver = "OpenGL";
+    display_driver = "opengl";
     allow_opengl = false;
     allow_xv = false;
     allow_xrandr = false;
@@ -227,7 +226,7 @@ int Snes9xConfig::save_config_file()
     outint("ScanlineFilterIntensity", scanline_filter_intensity, "0: 0%, 1: 12.5%, 2: 25%, 3: 50%, 4: 100%");
     outint("HiresEffect", hires_effect, "0: Downscale to low-res, 1: Leave as-is, 2: Upscale low-res screens");
     outint("NumberOfThreads", num_threads);
-    outstring("HardwareAcceleration", display_driver, "None, OpenGL, Xv, Vulkan");
+    outstring("HardwareAcceleration", display_driver, "none, opengl, xv, vulkan");
     outint("SplashBackground", splash_image, "0: Black, 1: Color bars, 2: Pattern, 3: Blue, 4: Default");
 
     section = "NTSC";

gtk/src/gtk_display.cpp

@@ -24,6 +24,7 @@
 #endif
 
 #include "gtk_display_driver_opengl.h"
+#include "gtk_display_driver_vulkan.h"
 
 void filter_scanlines(uint8 *, int, uint8 *, int, int, int);
 void filter_2x(uint8 *, int, uint8 *, int, int, int);
@@ -801,17 +802,21 @@ void S9xQueryDrivers()
 
     auto &dd = gui_config->display_drivers;
     dd.clear();
-    dd.push_back("None");
+    dd.push_back("none");
     if (gui_config->allow_opengl)
-        dd.push_back("OpenGL");
+        dd.push_back("opengl");
     if (gui_config->allow_xv)
-        dd.push_back("Xv");
+        dd.push_back("xv");
+    dd.push_back("vulkan");
 }
 
 bool8 S9xDeinitUpdate(int width, int height)
 {
     int yoffset = 0;
 
+    if (width <= 0 || height <= 0)
+        return false;
+
     if (top_level->last_height > height)
     {
         memset(GFX.Screen + GFX.RealPPL * height,
@@ -848,8 +853,8 @@ bool8 S9xDeinitUpdate(int width, int height)
             height = SNES_HEIGHT * 2;
         }
     }
-
-    uint16_t *screen_view = GFX.Screen + yoffset * GFX.RealPPL;
+    
+    uint16_t *screen_view = GFX.Screen + (yoffset * (int)GFX.RealPPL);
 
     if (!Settings.Paused && !NetPlay.Paused)
 
@@ -895,16 +900,20 @@ static void S9xInitDriver()
 #ifdef GDK_WINDOWING_WAYLAND
     if (GDK_IS_WAYLAND_DISPLAY(gdk_display_get_default()))
     {
-        gui_config->display_driver = "OpenGL";
+        gui_config->display_driver = "opengl";
     }
 #endif
 
-    if ("OpenGL" == gui_config->display_driver)
+    if ("opengl" == gui_config->display_driver)
     {
         driver = new S9xOpenGLDisplayDriver(top_level, gui_config);
     }
+    else if ("vulkan" == gui_config->display_driver)
+    {
+        driver = new S9xVulkanDisplayDriver(top_level, gui_config);
+    }
 #if defined(USE_XV) && defined(GDK_WINDOWING_X11)
-    else if ("Xv" == gui_config->display_driver)
+    else if ("xv" == gui_config->display_driver)
     {
         driver = new S9xXVDisplayDriver(top_level, gui_config);
     }
@@ -917,7 +926,7 @@ static void S9xInitDriver()
     if (driver->init())
     {
         delete driver;
-        gui_config->display_driver = "None";
+        gui_config->display_driver = "none";
         driver->init();
     }
 

gtk/src/gtk_display_driver_gtk.cpp

@@ -4,7 +4,6 @@
    For further information, consult the LICENSE file in the root directory.
 \*****************************************************************************/
 
-#include "gtk_compat.h"
 #include <cairo.h>
 #include "gtk_display.h"
 #include "gtk_display_driver_gtk.h"

gtk/src/gtk_display_driver_opengl.cpp

@@ -4,7 +4,6 @@
    For further information, consult the LICENSE file in the root directory.
 \*****************************************************************************/
 
-#include "gtk_compat.h"
 #include <dlfcn.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -13,7 +12,6 @@
 #include "gtk_display.h"
 #include "gtk_display_driver_opengl.h"
 #include "gtk_shader_parameters.h"
-#include "shaders/shader_helpers.h"
 
 static const GLchar *stock_vertex_shader_110 =
 "#version 110\n"
@@ -91,7 +89,7 @@ S9xOpenGLDisplayDriver::S9xOpenGLDisplayDriver(Snes9xWindow *window, Snes9xConfi
 void S9xOpenGLDisplayDriver::update(uint16_t *buffer, int width, int height, int stride_in_pixels)
 {
     Gtk::Allocation allocation = drawing_area->get_allocation();
-
+    
     if (output_window_width != allocation.get_width() ||
         output_window_height != allocation.get_height())
     {

gtk/src/gtk_display_driver_vulkan.cpp

@@ -0,0 +1,357 @@
+/*****************************************************************************\
+     Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
+                This file is licensed under the Snes9x License.
+   For further information, consult the LICENSE file in the root directory.
+\*****************************************************************************/
+
+#include "gtk_compat.h"
+#include "gtk_display.h"
+#include "gtk_display_driver_vulkan.h"
+#include "gtk_shader_parameters.h"
+#include "../../vulkan/vulkan_context.hpp"
+#include "../../vulkan/slang_shader.hpp"
+#include "../../vulkan/slang_helpers.hpp"
+#include "../../vulkan/vulkan_shader_chain.hpp"
+#include "snes9x.h"
+#include "gfx.h"
+#include "fmt/format.h"
+
+static const char *vertex_shader = R"(
+#version 450
+
+layout(location = 0) out vec2 texcoord;
+
+vec2 positions[3] = vec2[](vec2(-1.0, -3.0), vec2(3.0, 1.0), vec2(-1.0, 1.0));
+vec2 texcoords[3] = vec2[](vec2(0.0, -1.0), vec2(2.0, 1.0), vec2(0.0, 1.0));
+
+void main()
+{
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    texcoord = texcoords[gl_VertexIndex];
+}
+)";
+
+static const char *fragment_shader = R"(
+#version 450
+
+layout(location = 0) in vec2 texcoord;
+layout(binding = 0) uniform sampler2D tsampler;
+
+layout(location = 0) out vec4 fragcolor;
+
+void main()
+{
+    fragcolor = texture(tsampler, texcoord);
+}
+)";
+
+void S9xVulkanDisplayDriver::create_pipeline()
+{
+    auto vertex_spirv = SlangShader::generate_spirv(vertex_shader, "vertex");
+    auto fragment_spirv = SlangShader::generate_spirv(fragment_shader, "fragment");
+
+    auto vertex_module = device.createShaderModuleUnique({ {}, vertex_spirv });
+    auto fragment_module = device.createShaderModuleUnique({ {}, fragment_spirv });
+
+    vk::PipelineShaderStageCreateInfo vertex_ci;
+    vertex_ci.setStage(vk::ShaderStageFlagBits::eVertex)
+        .setModule(vertex_module.get())
+        .setPName("main");
+
+    vk::PipelineShaderStageCreateInfo fragment_ci;
+    fragment_ci.setStage(vk::ShaderStageFlagBits::eFragment)
+        .setModule(fragment_module.get())
+        .setPName("main");
+
+    std::vector<vk::PipelineShaderStageCreateInfo> stages = { vertex_ci, fragment_ci };
+
+    vk::PipelineVertexInputStateCreateInfo vertex_input_info{};
+
+    vk::PipelineInputAssemblyStateCreateInfo pipeline_input_assembly_info{};
+    pipeline_input_assembly_info.setTopology(vk::PrimitiveTopology::eTriangleList)
+        .setPrimitiveRestartEnable(false);
+
+    std::vector<vk::Viewport> viewports(1);
+    viewports[0]
+        .setX(0.0f)
+        .setY(0.0f)
+        .setWidth(256)
+        .setHeight(256)
+        .setMinDepth(0.0f)
+        .setMaxDepth(1.0f);
+    std::vector<vk::Rect2D> scissors(1);
+    scissors[0].extent.width = 256;
+    scissors[0].extent.height = 256;
+    scissors[0].offset = vk::Offset2D(0, 0);
+
+    vk::PipelineViewportStateCreateInfo pipeline_viewport_info;
+    pipeline_viewport_info.setViewports(viewports)
+        .setScissors(scissors);
+
+    vk::PipelineRasterizationStateCreateInfo rasterizer_info;
+    rasterizer_info.setCullMode(vk::CullModeFlagBits::eBack)
+        .setFrontFace(vk::FrontFace::eClockwise)
+        .setLineWidth(1.0f)
+        .setDepthClampEnable(false)
+        .setRasterizerDiscardEnable(false)
+        .setPolygonMode(vk::PolygonMode::eFill)
+        .setDepthBiasEnable(false)
+        .setRasterizerDiscardEnable(false);
+
+    vk::PipelineMultisampleStateCreateInfo multisample_info;
+    multisample_info.setSampleShadingEnable(false)
+        .setRasterizationSamples(vk::SampleCountFlagBits::e1);
+
+    vk::PipelineDepthStencilStateCreateInfo depth_stencil_info;
+    depth_stencil_info.setDepthTestEnable(false);
+
+    vk::PipelineColorBlendAttachmentState blend_attachment_info;
+    blend_attachment_info
+        .setColorWriteMask(vk::ColorComponentFlagBits::eB |
+                           vk::ColorComponentFlagBits::eG |
+                           vk::ColorComponentFlagBits::eR |
+                           vk::ColorComponentFlagBits::eA)
+        .setBlendEnable(true)
+        .setColorBlendOp(vk::BlendOp::eAdd)
+        .setSrcColorBlendFactor(vk::BlendFactor::eSrcAlpha)
+        .setDstColorBlendFactor(vk::BlendFactor::eOneMinusSrcAlpha)
+        .setAlphaBlendOp(vk::BlendOp::eAdd)
+        .setSrcAlphaBlendFactor(vk::BlendFactor::eOne)
+        .setSrcAlphaBlendFactor(vk::BlendFactor::eZero);
+
+    vk::PipelineColorBlendStateCreateInfo blend_state_info;
+    blend_state_info.setLogicOpEnable(false)
+        .setAttachments(blend_attachment_info);
+
+    std::vector<vk::DynamicState> states = { vk::DynamicState::eViewport, vk::DynamicState::eScissor };
+    vk::PipelineDynamicStateCreateInfo dynamic_state_info({}, states);
+
+    vk::DescriptorSetLayoutBinding dslb{};
+    dslb.setBinding(0)
+        .setStageFlags(vk::ShaderStageFlagBits::eFragment)
+        .setDescriptorCount(1)
+        .setDescriptorType(vk::DescriptorType::eCombinedImageSampler);
+    vk::DescriptorSetLayoutCreateInfo dslci{};
+    dslci.setBindings(dslb);
+    descriptor_set_layout = device.createDescriptorSetLayoutUnique(dslci);
+
+    vk::PipelineLayoutCreateInfo pipeline_layout_info;
+    pipeline_layout_info.setSetLayoutCount(0)
+        .setPushConstantRangeCount(0)
+        .setSetLayouts(descriptor_set_layout.get());
+
+    pipeline_layout = device.createPipelineLayoutUnique(pipeline_layout_info);
+
+    vk::GraphicsPipelineCreateInfo pipeline_create_info;
+    pipeline_create_info.setStageCount(2)
+        .setStages(stages)
+        .setPVertexInputState(&vertex_input_info)
+        .setPInputAssemblyState(&pipeline_input_assembly_info)
+        .setPViewportState(&pipeline_viewport_info)
+        .setPRasterizationState(&rasterizer_info)
+        .setPMultisampleState(&multisample_info)
+        .setPDepthStencilState(&depth_stencil_info)
+        .setPColorBlendState(&blend_state_info)
+        .setPDynamicState(&dynamic_state_info)
+        .setLayout(pipeline_layout.get())
+        .setRenderPass(swapchain->get_render_pass())
+        .setSubpass(0);
+
+    auto [result, pipeline] = device.createGraphicsPipelineUnique(nullptr, pipeline_create_info);
+    this->pipeline = std::move(pipeline);
+}
+ 
+S9xVulkanDisplayDriver::S9xVulkanDisplayDriver(Snes9xWindow *_window, Snes9xConfig *_config)
+{
+    window = _window;
+    config = _config;
+    drawing_area = window->drawing_area;
+    gdk_window = nullptr;
+    gdk_display = nullptr;
+    context.reset();
+}
+
+S9xVulkanDisplayDriver::~S9xVulkanDisplayDriver()
+{
+}
+
+void S9xVulkanDisplayDriver::refresh(int width, int height)
+{
+    if (!context)
+        return;
+
+    bool vsync_changed = context->swapchain->set_vsync(gui_config->sync_to_vblank);
+
+    auto new_width = drawing_area->get_width() * drawing_area->get_scale_factor();
+    auto new_height = drawing_area->get_height() * drawing_area->get_scale_factor();
+
+    if (new_width != current_width || new_height != current_height || vsync_changed)
+    {
+        context->recreate_swapchain();
+        context->wait_idle();
+        current_width = new_width;
+        current_height = new_height;
+    }
+
+    context->swapchain->set_vsync(gui_config->sync_to_vblank);
+}
+
+int S9xVulkanDisplayDriver::init()
+{
+    current_width = drawing_area->get_width() * drawing_area->get_scale_factor();
+    current_height = drawing_area->get_height() * drawing_area->get_scale_factor();
+    display = gdk_x11_display_get_xdisplay(drawing_area->get_display()->gobj());
+    xid = gdk_x11_window_get_xid(drawing_area->get_window()->gobj());
+
+    context = std::make_unique<Vulkan::Context>();
+    context->init(display, xid);
+    swapchain = context->swapchain.get();
+    device = context->device;
+
+    if (!gui_config->shader_filename.empty() && gui_config->use_shaders)
+    {
+        shaderchain = std::make_unique<Vulkan::ShaderChain>(context.get());
+        if (!shaderchain->load_shader_preset(gui_config->shader_filename))
+        {
+            fmt::print("Couldn't load shader preset file\n");
+            shaderchain = nullptr;
+        }
+        else
+        {
+            window->enable_widget("shader_parameters_item", true);
+            return 0;
+        }
+    }
+
+    create_pipeline();
+
+    descriptors.clear();
+    for (size_t i = 0; i < swapchain->get_num_frames(); i++)
+    {
+        vk::DescriptorSetAllocateInfo dsai{};
+        dsai
+            .setDescriptorPool(context->descriptor_pool.get())
+            .setDescriptorSetCount(1)
+            .setSetLayouts(descriptor_set_layout.get());
+        auto descriptor = device.allocateDescriptorSetsUnique(dsai);
+        descriptors.push_back(std::move(descriptor[0]));
+    }
+    
+    textures.clear();
+    textures.resize(swapchain->get_num_frames());
+    for (auto &t : textures)
+    {
+        t.init(context.get());
+        t.create(256, 224, vk::Format::eR5G6B5UnormPack16, vk::SamplerAddressMode::eClampToEdge, Settings.BilinearFilter, false);
+    }
+
+    vk::SamplerCreateInfo sci{};
+    sci.setAddressModeU(vk::SamplerAddressMode::eClampToEdge)
+        .setAddressModeV(vk::SamplerAddressMode::eClampToEdge)
+        .setAddressModeW(vk::SamplerAddressMode::eClampToEdge)
+        .setMipmapMode(vk::SamplerMipmapMode::eLinear)
+        .setAnisotropyEnable(false)
+        .setMinFilter(vk::Filter::eLinear)
+        .setMagFilter(vk::Filter::eLinear)
+        .setUnnormalizedCoordinates(false)
+        .setMinLod(1.0f)
+        .setMaxLod(1.0f)
+        .setMipLodBias(0.0)
+        .setCompareEnable(false);
+    linear_sampler = device.createSampler(sci);
+
+    sci.setMinFilter(vk::Filter::eNearest)
+       .setMagFilter(vk::Filter::eNearest);
+    nearest_sampler = device.createSampler(sci);
+
+    return 0;
+}
+
+void S9xVulkanDisplayDriver::deinit()
+{
+    if (!context)
+        return;
+
+    if (shaderchain)
+        gtk_shader_parameters_dialog_close();
+
+    context->wait_idle();
+    textures.clear();
+    descriptors.clear();
+    device.destroySampler(linear_sampler);
+    device.destroySampler(nearest_sampler);
+}
+
+void S9xVulkanDisplayDriver::update(uint16_t *buffer, int width, int height, int stride_in_pixels)
+{
+    if (!context)
+        return;
+
+    auto viewport = S9xApplyAspect(width, height, current_width, current_height);
+
+    if (shaderchain)
+    {
+        shaderchain->do_frame((uint8_t *)buffer, width, height, stride_in_pixels << 1, vk::Format::eR5G6B5UnormPack16, viewport.x, viewport.y, viewport.w, viewport.h);
+        return;
+    }
+
+    if (!swapchain->begin_frame())
+        return;
+
+    auto &tex = textures[swapchain->get_current_frame()];
+    auto &cmd = swapchain->get_cmd();
+    auto extents = swapchain->get_extents();
+    auto &dstset = descriptors[swapchain->get_current_frame()].get();
+
+    tex.from_buffer(cmd, (uint8_t *)buffer, width, height, stride_in_pixels * 2);
+
+    swapchain->begin_render_pass();
+
+    vk::DescriptorImageInfo dii{};
+    dii.setImageView(tex.image_view)
+        .setSampler(Settings.BilinearFilter ? linear_sampler : nearest_sampler)
+        .setImageLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+    vk::WriteDescriptorSet wds{};
+    wds.setDescriptorCount(1)
+        .setDstBinding(0)
+        .setDstArrayElement(0)
+        .setDstSet(dstset)
+        .setDescriptorType(vk::DescriptorType::eCombinedImageSampler)
+        .setImageInfo(dii);
+    device.updateDescriptorSets(wds, {});
+
+    cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline.get());
+    cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout.get(), 0, dstset, {});
+
+    auto dest_rect = S9xApplyAspect(width, height, extents.width, extents.height);
+
+    cmd.setViewport(0, vk::Viewport(dest_rect.x, dest_rect.y, dest_rect.w, dest_rect.h, 0.0f, 1.0f));
+    cmd.setScissor(0, vk::Rect2D({}, extents));
+    cmd.draw(3, 1, 0, 0);
+
+    swapchain->end_render_pass();
+    swapchain->end_frame();
+}
+
+int S9xVulkanDisplayDriver::query_availability()
+{
+    return 0;
+}
+
+void *S9xVulkanDisplayDriver::get_parameters()
+{
+    if (shaderchain)
+        return &shaderchain->preset->parameters;
+    return nullptr;
+}
+
+void S9xVulkanDisplayDriver::save(const char *filename)
+{
+    if (shaderchain)
+        shaderchain->preset->save_to_file(filename);
+}
+
+bool S9xVulkanDisplayDriver::is_ready()
+{
+    return true;
+}

gtk/src/gtk_display_driver_vulkan.h

@@ -0,0 +1,55 @@
+/*****************************************************************************\
+     Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
+                This file is licensed under the Snes9x License.
+   For further information, consult the LICENSE file in the root directory.
+\*****************************************************************************/
+
+#pragma once
+#include "gtk_s9x.h"
+#include "gtk_display_driver.h"
+#include "../../vulkan/vulkan_context.hpp"
+#include "../../vulkan/vulkan_texture.hpp"
+#include "../../vulkan/slang_preset.hpp"
+#include "../../vulkan/vulkan_shader_chain.hpp"
+
+class S9xVulkanDisplayDriver : public S9xDisplayDriver
+{
+  public:
+    S9xVulkanDisplayDriver(Snes9xWindow *window, Snes9xConfig *config);
+    ~S9xVulkanDisplayDriver();
+    void refresh(int width, int height) override;
+    int init() override;
+    void deinit() override;
+    void update(uint16_t *buffer, int width, int height, int stride_in_pixels) override;
+    void *get_parameters() override;
+    void save(const char *filename) override;
+    bool is_ready() override;
+
+    static int query_availability();
+
+  private:
+    std::unique_ptr<Vulkan::Context> context;
+    Vulkan::Swapchain *swapchain;
+    vk::Device device;
+    
+    GdkDisplay *gdk_display;
+    GdkWindow *gdk_window;
+    Display *display;
+    Window xid;
+    Colormap colormap;
+    int current_width;
+    int current_height;
+
+    void create_pipeline();
+    vk::UniqueDescriptorSetLayout descriptor_set_layout;
+    vk::UniquePipelineLayout pipeline_layout;
+    vk::UniquePipeline pipeline;
+    vk::Sampler linear_sampler;
+    vk::Sampler nearest_sampler;
+
+    void draw_buffer(uint8_t *buffer, int width, int height, int byte_stride);
+    bool filter = true;
+    std::vector<Vulkan::Texture> textures;
+    std::vector<vk::UniqueDescriptorSet> descriptors;
+    std::unique_ptr<Vulkan::ShaderChain> shaderchain;
+};

gtk/src/gtk_preferences.cpp

@@ -141,10 +141,12 @@ Snes9xPreferences::Snes9xPreferences(Snes9xConfig *config)
     for (const auto &driver : config->display_drivers)
     {
         std::string entry;
-        if (!strcasecmp(driver.c_str(), "opengl"))
+        if (driver == "opengl")
             entry = _("OpenGL - Use 3D graphics hardware");
-        else if (!strcasecmp(driver.c_str(), "Xv"))
+        else if (driver == "xv")
             entry = _("XVideo - Use hardware video blitter");
+        else if (driver == "vulkan")
+            entry = _("Vulkan");
         else
             entry = _("None - Use software scaler");
 
@@ -176,9 +178,10 @@ void Snes9xPreferences::connect_signals()
 
     get_object<Gtk::ComboBox>("hw_accel")->signal_changed().connect([&] {
         int id = get_combo("hw_accel");
-        show_widget("bilinear_filter", config->display_drivers[id] != "Xv");
-        show_widget("opengl_frame", config->display_drivers[id] == "OpenGL");
-        show_widget("xv_frame", config->display_drivers[id] == "Xv");
+        show_widget("bilinear_filter", config->display_drivers[id] != "xv");
+        show_widget("opengl_frame", config->display_drivers[id] == "opengl" ||
+                    config->display_drivers[id] == "vulkan");
+        show_widget("xv_frame", config->display_drivers[id] == "xv");
     });
 
     get_object<Gtk::Button>("reset_current_joypad")->signal_pressed().connect(sigc::mem_fun(*this, &Snes9xPreferences::reset_current_joypad));

gtk/src/gtk_s9x.cpp

@@ -6,8 +6,6 @@
 
 #include <stdio.h>
 #include <signal.h>
-#include "giomm/application.h"
-#include "glibmm/main.h"
 #include "gtk_compat.h"
 #include "gtk_config.h"
 #include "gtk_s9x.h"
@@ -84,6 +82,10 @@ int main(int argc, char *argv[])
         exit(3);
 
     top_level = new Snes9xWindow(gui_config);
+#ifdef GDK_WINDOWING_X11
+    if (!GDK_IS_X11_WINDOW(top_level->window->get_window()->gobj()))
+        XInitThreads();
+#endif
 
     // Setting fullscreen before showing the window avoids some flicker.
     if ((gui_config->full_screen_on_open && rom_filename) || (gui_config->fullscreen))

gtk/src/gtk_s9xwindow.cpp

@@ -515,6 +515,7 @@ void Snes9xWindow::setup_splash()
 
         return;
     }
+    return;
 
     for (int y = 0; y < 224; y++, screen_ptr += (GFX.Pitch / 2)) {
         memset(screen_ptr, 0, 256 * sizeof(uint16));

gtk/src/gtk_sound_driver_sdl.cpp

@@ -5,6 +5,7 @@
 \*****************************************************************************/
 
 #include "gtk_sound_driver_sdl.h"
+#include "SDL_audio.h"
 #include "gtk_s9x.h"
 #include "apu/apu.h"
 #include "snes9x.h"
@@ -85,6 +86,12 @@ bool S9xSDLSoundDriver::open_device()
 
     audiospec.userdata = this;
 
+    char *name;
+    SDL_AudioSpec spec;
+    SDL_GetDefaultAudioInfo(&name, &spec, 0);
+    printf("%s\n", name);
+    SDL_free(name);
+
     printf("SDL sound driver initializing...\n");
     printf("    --> (Frequency: %dhz, Latency: %dms)...",
            audiospec.freq,

memmap.cpp

@@ -3994,7 +3994,7 @@ void CMemory::CheckForAnyPatch (const char *rom_filename, bool8 header, int32 &r
 #endif
 
 	// BPS
-	std::string filename = patch_path + S9xGetFilename(".bps", PATCH_DIR);
+	std::string filename = S9xGetFilename(".bps", PATCH_DIR);
 
 	if ((patch_file = OPEN_FSTREAM(filename.c_str(), "rb")) != NULL)
 	{
@@ -4014,7 +4014,7 @@ void CMemory::CheckForAnyPatch (const char *rom_filename, bool8 header, int32 &r
 	}
 
 	// UPS
-	filename = patch_path + S9xGetFilename(".ups", PATCH_DIR);
+	filename = S9xGetFilename(".ups", PATCH_DIR);
 
 	if ((patch_file = OPEN_FSTREAM(filename.c_str(), "rb")) != NULL)
 	{
@@ -4034,7 +4034,7 @@ void CMemory::CheckForAnyPatch (const char *rom_filename, bool8 header, int32 &r
 	}
 
 	// IPS
-	filename = patch_path + S9xGetFilename(".ips", PATCH_DIR);
+	filename = S9xGetFilename(".ips", PATCH_DIR);
 
 	if ((patch_file = OPEN_FSTREAM(filename.c_str(), "rb")) != NULL)
 	{

shaders/glsl.cpp

@@ -340,10 +340,14 @@ void GLSLShader::read_shader_file_with_includes(std::string filename,
         }
         else if (line.compare(0, 17, "#pragma parameter") == 0)
         {
+            char id[PATH_MAX];
+            char name[PATH_MAX];
             GLSLParam par;
 
             sscanf(line.c_str(), "#pragma parameter %s \"%[^\"]\" %f %f %f %f",
-                   par.id, par.name, &par.val, &par.min, &par.max, &par.step);
+                   id, name, &par.val, &par.min, &par.max, &par.step);
+            par.id = id;
+            par.name = name;
 
             unsigned int last_decimal = line.rfind(".") + 1;
             unsigned int index = last_decimal;
@@ -359,7 +363,7 @@ void GLSLShader::read_shader_file_with_includes(std::string filename,
             unsigned int i = 0;
             for (; i < param.size(); i++)
             {
-                if (!strcmp(param[i].id, par.id))
+                if (param[i].id == par.id)
                     break;
             }
             if (i >= param.size())
@@ -650,7 +654,7 @@ bool GLSLShader::load_shader(const char *filename)
     {
         char key[266];
         const char *value;
-        snprintf (key, 266, "::%s", param[i].id);
+        snprintf (key, 266, "::%s", param[i].id.c_str());
         value = conf.GetString (key, NULL);
         if (value)
         {
@@ -947,6 +951,7 @@ void GLSLShader::register_uniforms()
     max_prev_frame = 0;
     char varname[100];
 
+    unif.resize(pass.size());
     for (unsigned int i = 1; i < pass.size(); i++)
     {
         GLSLUniforms *u = &pass[i].unif;
@@ -1027,9 +1032,10 @@ void GLSLShader::register_uniforms()
             u->Lut[j] = glGetUniformLocation(program, lut[j].id);
         }
 
-        for (unsigned int j = 0; j < param.size(); j++)
+        unif[i].resize(param.size());
+        for (unsigned int param_num = 0; param_num < param.size(); param_num++)
         {
-            param[j].unif[i] = glGetUniformLocation(program, param[j].id);
+            unif[i][param_num] = glGetUniformLocation(program, param[param_num].id.c_str());
         }
     }
 
@@ -1160,7 +1166,7 @@ void GLSLShader::set_shader_vars(unsigned int p, bool inverted)
     // User and Preset Parameters
     for (unsigned int i = 0; i < param.size(); i++)
     {
-        setUniform1f(param[i].unif[p], param[i].val);
+        setUniform1f(unif[p][i], param[i].val);
     }
 
     glActiveTexture(GL_TEXTURE0);
@@ -1230,14 +1236,14 @@ void GLSLShader::save(const char *filename)
         fprintf(file, "parameters = \"");
         for (unsigned int i = 0; i < param.size(); i++)
         {
-            fprintf(file, "%s%c", param[i].id, (i == param.size() - 1) ? '\"' : ';');
+            fprintf(file, "%s%c", param[i].id.c_str(), (i == param.size() - 1) ? '\"' : ';');
         }
         fprintf(file, "\n");
     }
 
     for (unsigned int i = 0; i < param.size(); i++)
     {
-        fprintf(file, "%s = \"%f\"\n", param[i].id, param[i].val);
+        fprintf(file, "%s = \"%f\"\n", param[i].id.c_str(), param[i].val);
     }
 
     if (lut.size() > 0)

shaders/glsl.h

@@ -145,14 +145,13 @@ struct GLSLLut
 
 struct GLSLParam
 {
-    char name[PATH_MAX];
-    char id[256];
+    std::string name;
+    std::string id;
     float min;
     float max;
     float val;
     float step;
     int digits;
-    GLint unif[glsl_max_passes];
 };
 
 struct GLSLShader
@@ -178,6 +177,8 @@ struct GLSLShader
     std::vector<GLSLPass> pass;
     std::vector<GLSLLut> lut;
     std::vector<GLSLParam> param;
+    std::vector<std::vector<GLint>> unif;
+
     int max_prev_frame;
     std::deque<GLSLPass> prev_frame;
     std::vector<GLuint> vaos;

vulkan/slang_helpers.cpp

@@ -0,0 +1,128 @@
+#include "slang_helpers.hpp"
+
+#include <string>
+#include <vector>
+#include <filesystem>
+#include <cmath>
+
+using std::string;
+using std::string_view;
+using std::vector;
+namespace fs = std::filesystem;
+
+int mipmap_levels_for_size(int width, int height)
+{
+    return (int)log2(width > height ? width : height);
+}
+
+void trim(string_view &view)
+{
+    while (view.length() > 0 && isspace(view.at(0)))
+        view.remove_prefix(1);
+    
+    while (view.length() > 0 && isspace(view.at(view.length() - 1)))
+        view.remove_suffix(1);
+}
+
+string trim(const string& str)
+{
+    string_view sv(str);
+    trim(sv);
+    return string(sv);
+}
+
+int get_significant_digits(const string_view &view) 
+{
+    auto pos = view.rfind('.');
+    if (pos == string_view::npos)
+        return 0;
+    return view.size() - pos - 1;
+}
+
+vector<string> split_string_quotes(const string_view &view)
+{
+    vector<string> tokens;
+    size_t pos = 0;
+
+    while (pos < view.length())
+    {
+        size_t indexa = view.find_first_not_of("\t\r\n ", pos);
+        size_t indexb = 0;
+        if (indexa == string::npos)
+            break;
+
+        if (view.at(indexa) == '\"')
+        {
+            indexa++;
+            indexb = view.find_first_of('\"', indexa);
+            if (indexb == string::npos)
+                break;
+        }
+        else 
+        {
+            indexb = view.find_first_of("\t\r\n ", indexa);
+            if (indexb == string::npos)
+                indexb = view.size();
+        }
+        
+        if (indexb > indexa)
+            tokens.push_back(string{view.substr(indexa, indexb - indexa)});
+        pos = indexb + 1;
+    }
+
+    return tokens;
+}
+
+vector<string> split_string(const string_view &str, unsigned char delim)
+{
+    vector<string> tokens;
+    size_t pos = 0;
+    size_t index;
+    
+    while (pos < str.length())
+    {
+        index = str.find(delim, pos);
+        if (index == string::npos)
+        {
+            if (pos < str.length())
+            {
+                tokens.push_back(string{str.substr(pos)}); 
+            }
+
+            break;
+        }
+        else if (index > pos)
+        {
+            tokens.push_back(string{str.substr(pos, index - pos)});
+        }
+
+        pos = index + 1;
+    } 
+
+    return tokens;
+}
+
+bool ends_with(const string &str, const string &ext)
+{
+    if (ext.size() > str.size())
+        return false;
+
+    auto icmp = [](const unsigned char a, const unsigned char b) -> bool {
+        return std::tolower(a) == std::tolower(b);
+    };
+    
+    return std::equal(ext.crbegin(), ext.crend(), str.crbegin(), icmp);
+}
+
+void canonicalize(string &filename, const string &base)
+{
+    fs::path path(filename);
+
+    if (path.is_relative())
+    {
+        fs::path base_path(base);
+        base_path.remove_filename();
+        path = fs::weakly_canonical(base_path / path);
+        filename = path.string();
+    }
+}

vulkan/slang_helpers.hpp

@@ -0,0 +1,13 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <string_view>
+
+int get_significant_digits(const std::string_view &view);
+std::string trim(const std::string &str);
+void trim(std::string_view &view);
+std::vector<std::string> split_string(const std::string_view &str, unsigned char delim);
+std::vector<std::string> split_string_quotes(const std::string_view &view);
+bool ends_with(const std::string &str, const std::string &ext);
+void canonicalize(std::string &filename, const std::string &base);
+int mipmap_levels_for_size(int width, int height);

vulkan/slang_preset.cpp

@@ -0,0 +1,842 @@
+#include "slang_preset.hpp"
+#include "../external/SPIRV-Cross/spirv.hpp"
+#include "slang_helpers.hpp"
+#include "slang_preset_ini.hpp"
+
+#include <string>
+#include <cstdio>
+#include <vector>
+#include <cctype>
+#include <iostream>
+#include <fstream>
+#include <filesystem>
+#include <unordered_map>
+#include "../external/SPIRV-Cross/spirv_cross.hpp"
+#include "../external/SPIRV-Cross/spirv_glsl.hpp"
+#include "slang_shader.hpp"
+#include "../../conffile.h"
+
+using std::string;
+using std::to_string;
+
+SlangPreset::SlangPreset()
+{
+}
+
+SlangPreset::~SlangPreset()
+{
+}
+#if 1
+bool SlangPreset::load_preset_file(string filename)
+{
+    if (!ends_with(filename, ".slangp"))
+        return false;
+
+    IniFile conf;
+
+    if (!conf.load_file(filename))
+        return false;
+
+    int num_passes = conf.get_int("shaders", 0);
+
+    if (num_passes <= 0)
+        return false;
+
+    passes.resize(num_passes);
+
+    // ConfFile.cpp searches global keys using a "::" prefix. .slang shaders
+    // indicate data specific to shader pass by appending the pass number.
+    int index;
+    auto key = [&](string s) -> string { return s + to_string(index); };
+    auto iGetBool = [&](string s, bool def = false) -> bool {
+        return conf.get_bool(key(s), def);
+    };
+    auto iGetString = [&](string s, string def = "") -> string {
+        return conf.get_string(key(s), def);
+    };
+    auto iGetFloat = [&](string s, float def = 1.0f) -> float {
+        return conf.get_float(key(s), def);
+    };
+    auto iGetInt = [&](string s, int def = 0) -> int {
+        return conf.get_int(key(s), def);
+    };
+
+    for (index = 0; index < num_passes; index++)
+    {
+        auto &shader = passes[index];
+        shader.filename = iGetString("shader", "");
+        canonicalize(shader.filename, conf.get_source(key("shader")));
+        shader.alias = iGetString("alias", "");
+        shader.filter_linear = iGetBool("filter_linear");
+        shader.mipmap_input = iGetBool("mipmap_input");
+        shader.float_framebuffer = iGetBool("float_framebuffer");
+        shader.srgb_framebuffer = iGetBool("srgb_framebuffer");
+        shader.frame_count_mod = iGetInt("frame_count_mod", 0);
+        shader.wrap_mode = iGetString("wrap_mode");
+        // Is this correct? It gives priority to _x and _y scale types.
+        string scale_type = iGetString("scale_type", "undefined");
+        shader.scale_type_x = iGetString("scale_type_x", scale_type);
+        shader.scale_type_y = iGetString("scale_type_y", scale_type);
+        shader.scale_x = iGetFloat("scale_x", 1.0f);
+        shader.scale_y = iGetFloat("scale_y", 1.0f);
+        if (conf.exists(key("scale")))
+        {
+            float scale = iGetFloat("scale");
+            shader.scale_x = scale;
+            shader.scale_y = scale;
+        }
+    }
+
+    string texture_string = conf.get_string("textures", "");
+    if (!texture_string.empty())
+    {
+        auto texture_list = split_string(texture_string, ';');
+
+        for (auto &id : texture_list)
+        {
+            Texture texture;
+            texture.id = trim(id);
+            textures.push_back(texture);
+        }
+
+        for (auto &t : textures)
+        {
+            t.wrap_mode = conf.get_string(t.id + "_wrap_mode", "");
+            t.mipmap = conf.get_bool(t.id + "_mipmap", false);
+            t.linear = conf.get_bool(t.id + "_linear", false);
+            t.filename = conf.get_string(t.id, "");
+            canonicalize(t.filename, conf.get_source(t.id));
+        }
+    }
+
+    for (auto &shader : passes)
+    {
+        if (!shader.load_file())
+            return false;
+    }
+
+    for (auto &texture : textures)
+        canonicalize(texture.filename, conf.textures_filename);
+
+    gather_parameters();
+
+    for (auto &p : parameters)
+    {
+        auto value_str = conf.get_string(p.id, "");
+        if (!value_str.empty())
+        {
+            p.val = atof(value_str.c_str());
+            if (p.val < p.min)
+                p.val = p.min;
+            else if (p.val > p.max)
+                p.val = p.max;
+        }
+    }
+
+    return true;
+}
+#else
+bool SlangPreset::load_preset_file(string filename)
+{
+    if (!ends_with(filename, ".slangp"))
+        return false;
+
+    ConfigFile conf;
+
+    if (!conf.LoadFile(filename.c_str()))
+        return false;
+
+    int num_passes = conf.GetInt("::shaders", 0);
+
+    if (num_passes <= 0)
+        return false;
+
+    passes.resize(num_passes);
+
+    // ConfFile.cpp searches global keys using a "::" prefix. .slang shaders
+    // indicate data specific to shader pass by appending the pass number.
+    int index;
+    auto key = [&](string s) -> string { return "::" + s + to_string(index); };
+    auto iGetBool = [&](string s, bool def = false) -> bool {
+        return conf.GetBool(key(s).c_str(), def);
+    };
+    auto iGetString = [&](string s, string def = "") -> string {
+        return conf.GetString(key(s).c_str(), def);
+    };
+    auto iGetFloat = [&](string s, float def = 1.0f) -> float {
+        return std::stof(conf.GetString(key(s).c_str(), to_string(def).c_str()));
+    };
+    auto iGetInt = [&](string s, int def = 0) -> int {
+        return conf.GetInt(key(s).c_str(), def);
+    };
+
+    for (index = 0; index < num_passes; index++)
+    {
+        auto &shader = passes[index];
+        shader.filename = iGetString("shader", "");
+        shader.alias = iGetString("alias", "");
+        shader.filter_linear = iGetBool("filter_linear");
+        shader.mipmap_input = iGetBool("mipmap_input");
+        shader.float_framebuffer = iGetBool("float_framebuffer");
+        shader.srgb_framebuffer = iGetBool("srgb_framebuffer");
+        shader.frame_count_mod = iGetInt("frame_count_mod", 0);
+        shader.wrap_mode = iGetString("wrap_mode");
+        // Is this correct? It gives priority to _x and _y scale types.
+        string scale_type = iGetString("scale_type", "undefined");
+        shader.scale_type_x = iGetString("scale_type_x", scale_type);
+        shader.scale_type_y = iGetString("scale_type_y", scale_type);
+        shader.scale_x = iGetFloat("scale_x", 1.0f);
+        shader.scale_y = iGetFloat("scale_y", 1.0f);
+        if (conf.Exists(key("scale").c_str()))
+        {
+            float scale = iGetFloat("scale");
+            shader.scale_x = scale;
+            shader.scale_y = scale;
+        }
+    }
+
+    string texture_string = conf.GetString("::textures", "");
+    if (!texture_string.empty())
+    {
+        auto texture_list = split_string(texture_string, ';');
+
+        for (auto &id : texture_list)
+        {
+            Texture texture;
+            texture.id = trim(id);
+            textures.push_back(texture);
+        }
+
+        for (auto &t : textures)
+        {
+            t.wrap_mode = conf.GetString(("::" + t.id + "_wrap_mode").c_str(), "");
+            t.mipmap = conf.GetBool(("::" + t.id + "_mipmap").c_str(), "");
+            t.linear = conf.GetBool(("::" + t.id + "_linear").c_str(), "");
+            t.filename = conf.GetString(("::" + t.id).c_str(), "");
+        }
+    }
+
+    for (auto &shader : passes)
+    {
+        canonicalize(shader.filename, filename);
+        if (!shader.load_file())
+            return false;
+    }
+
+    for (auto &texture : textures)
+        canonicalize(texture.filename, filename);
+
+    gather_parameters();
+
+    for (auto &p : parameters)
+    {
+        auto value_str = conf.GetString(("::" + p.id).c_str());
+        if (value_str)
+        {
+            p.val = atof(value_str);
+            if (p.val < p.min)
+                p.val = p.min;
+            else if (p.val > p.max)
+                p.val = p.max;
+        }
+    }
+
+    return true;
+}
+#endif
+/*
+    Aggregates the parameters from individual stages and separate shader files,
+    resolving duplicates.
+*/
+void SlangPreset::gather_parameters()
+{
+    std::unordered_map<std::string, SlangShader::Parameter> map;
+
+    for (auto &s : passes)
+    {
+        for (auto &p : s.parameters)
+        {
+            map.insert({ p.id, p });
+        }
+    }
+    
+    parameters.clear();
+    for (auto &p : map)
+        parameters.push_back(p.second);
+}
+
+/*
+    Print to stdout the entire shader preset chain and parameters, minus source
+    and SPIRV output
+*/
+void SlangPreset::print()
+{
+    printf("Number of Shaders: %zu\n", passes.size());
+    for (size_t i = 0; i < passes.size(); i++)
+    {
+        auto &s = passes[i];
+        printf(" Shader \n");
+        printf("  filename:          %s\n", s.filename.c_str());
+        printf("  alias:             %s\n", s.alias.c_str());
+        printf("  filter_linear:     %d\n", s.filter_linear);;
+        printf("  mipmap_input:      %d\n", s.mipmap_input);
+        printf("  float_framebuffer: %d\n", s.float_framebuffer);
+        printf("  srgb_framebuffer:  %d\n", s.srgb_framebuffer);
+        printf("  frame_count_mod:   %d\n", s.frame_count_mod);
+        printf("  wrap_mode:         %s\n", s.wrap_mode.c_str());
+        printf("  scale_type_x:      %s\n", s.scale_type_x.c_str());
+        printf("  scale_type_y:      %s\n", s.scale_type_y.c_str());
+        printf("  scale_x:           %f\n", s.scale_x);
+        printf("  scale_y:           %f\n", s.scale_y);
+        printf("  pragma lines: ");
+        for (auto &p : s.pragma_stage_lines)
+            printf("%zu ", p);
+        printf("\n");
+        printf("  Number of parameters:    %zu\n", s.parameters.size());
+        for (auto &p : s.parameters)
+        {
+            printf("   %s \"%s\" min: %f max: %f val: %f step: %f digits: %d\n",
+                p.id.c_str(), p.name.c_str(), p.min, p.max, p.val, p.step, p.significant_digits);
+        }
+
+        printf("  Uniforms: %zu\n", s.uniforms.size());
+        printf("   UBO size: %zu, binding: %d\n", s.ubo_size, s.ubo_binding);
+        printf("   Push Constant block size: %zu\n", s.push_constant_block_size);
+        for (auto &u : s.uniforms)
+        {
+            const char *strings[] = {
+                "Output Size",
+                "Previous Frame Size",
+                "Pass Size",
+                "Pass Feedback Size",
+                "Lut Size",
+                "MVP Matrix",
+                "Frame Count",
+                "Parameter"
+            };
+
+            const char *block = u.block == SlangShader::Uniform::UBO ? "UBO" : "Push Constants";
+            const char *type = strings[u.type];
+
+            printf("   ");
+            switch (u.type)
+            {
+            case SlangShader::Uniform::Type::ViewportSize:
+                printf("%s at offset %zu in %s\n", type, u.offset, block);
+                break;
+            case SlangShader::Uniform::Type::PreviousFrameSize:
+            case SlangShader::Uniform::Type::PassSize:
+            case SlangShader::Uniform::Type::PassFeedbackSize:
+            case SlangShader::Uniform::Type::LutSize:
+                printf("%s %d at offset %zu in %s\n", type, u.specifier, u.offset, block);
+                break;
+            case SlangShader::Uniform::Type::MVP:
+            case SlangShader::Uniform::Type::FrameCount:
+                printf("%s at offset %zu in %s\n", type, u.offset, block);
+                break;
+            case SlangShader::Uniform::Type::Parameter:
+                printf("%s #%d named \"%s\" at offset %zu in %s\n", type, u.specifier, parameters[u.specifier].id.c_str(), u.offset, block);
+            default:
+                break;
+            }
+        }
+
+        printf("  Samplers: %zu\n", s.samplers.size());
+        for (auto &sampler : s.samplers)
+        {
+            const char *strings[] = 
+            { 
+                "Previous Frame",
+                "Pass",
+                "Pass Feedback",
+                "Lut",
+            };
+
+            const char *type = strings[sampler.type];
+
+            printf("   ");
+            switch (sampler.type)
+            {
+                case SlangShader::Sampler::Type::PreviousFrame:
+                case SlangShader::Sampler::Type::Pass:
+                case SlangShader::Sampler::Type::PassFeedback:
+                    printf("%s %d at binding %d\n", type, sampler.specifier, sampler.binding);
+                    break;
+                case SlangShader::Sampler::Type::Lut:
+                    printf("%s %d \"%s\" at binding %d\n", type, sampler.specifier, textures[sampler.specifier].id.c_str(), sampler.binding);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    printf("Num textures: %zu\n", textures.size());
+    for (size_t i = 0; i < textures.size(); i++)
+    {
+        auto &t = textures[i];
+        printf(" Texture %zu\n", i);
+        printf("  id:        %s\n", t.id.c_str());
+        printf("  filename:  %s\n", t.filename.c_str());
+        printf("  wrap_mode: %s\n", t.wrap_mode.c_str());
+        printf("  mipmap:    %d\n", t.mipmap);
+        printf("  linear:    %d\n", t.linear);
+    }
+
+    printf("Parameters: %zu count\n", parameters.size());
+    for (size_t i = 0; i < parameters.size(); i++)
+    {
+        auto &p = parameters[i];
+
+        printf(" Parameter: %zu\n", i);
+        printf("  id:         %s\n", p.id.c_str());
+        printf("  name:       %s\n", p.name.c_str());
+        printf("  min:        %f\n", p.min);
+        printf("  max:        %f\n", p.max);
+        printf("  step:       %f\n", p.step);
+        printf("  sigdigits:  %d\n", p.significant_digits);
+        printf("  value:      %f\n", p.val);
+    }
+
+    printf("Oldest previous frame used: %d\n", oldest_previous_frame);
+}
+
+bool SlangPreset::match_sampler_semantic(const string &name, int pass, SlangShader::Sampler::Type &type, int &specifier)
+{
+    auto match_with_specifier = [&name, &specifier](string prefix) -> bool {
+        if (name.compare(0, prefix.length(), prefix) != 0)
+            return false;
+
+        if (name.length() <= prefix.length())
+            return false;
+
+        for (auto iter = name.begin() + prefix.length(); iter < name.end(); iter++)
+        {
+            if (!std::isdigit(*iter))
+                return false;
+        }
+
+        specifier = std::stoi(name.substr(prefix.length()));
+        return true;
+    };
+
+    if (name == "Original")
+    {
+        type = SlangShader::Sampler::Type::Pass;
+        specifier = -1;
+        return true;
+    }
+    else if (name == "Source") 
+    {
+        type = SlangShader::Sampler::Type::Pass;
+        specifier = pass - 1;
+        return true;
+    }
+    else if (match_with_specifier("OriginalHistory"))
+    {
+        type = SlangShader::Sampler::Type::PreviousFrame;
+        return true;
+    }
+    else if (match_with_specifier("PassOutput"))
+    {
+        type = SlangShader::Sampler::Type::Pass;
+        return true;
+    }
+    else if (match_with_specifier("PassFeedback"))
+    {
+        type = SlangShader::Sampler::Type::PassFeedback;
+        return true;
+    }
+    else if (match_with_specifier("User"))
+    {
+        type = SlangShader::Sampler::Type::Lut;
+        return true;
+    }
+    else 
+    {
+        for (size_t i = 0; i < passes.size(); i++)
+        {
+            if (passes[i].alias == name)
+            {
+                type = SlangShader::Sampler::Type::Pass;
+                specifier = i;
+                return true;
+            }
+            else if (passes[i].alias + "Feedback" == name) 
+            {
+                type = SlangShader::Sampler::Type::PassFeedback;
+                specifier = i;
+                return true;
+            }
+        }
+    }
+
+    for (size_t i = 0; i < textures.size(); i++)
+    {
+        if (name == textures[i].id)
+        {
+            type = SlangShader::Sampler::Type::Lut;
+            specifier = i;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool SlangPreset::match_buffer_semantic(const string &name, int pass, SlangShader::Uniform::Type &type, int &specifier)
+{
+    if (name == "MVP")
+    {
+        type = SlangShader::Uniform::Type::MVP;
+        return true;
+    }
+    
+    if (name == "FrameCount")
+    {
+        type = SlangShader::Uniform::Type::FrameCount;
+        return true;
+    }
+
+    if (name == "FinalViewportSize")
+    {
+        type = SlangShader::Uniform::Type::ViewportSize;
+        return true;
+    }
+
+    if (name == "FrameDirection")
+    {
+        type = SlangShader::Uniform::Type::FrameDirection;
+        return true;
+    }
+
+    if (name.find("Size") != string::npos)
+    {
+        auto match = [&name, &specifier](string prefix) -> bool {
+            if (name.compare(0, prefix.length(), prefix) != 0)
+                return false;
+
+            if (name.compare(prefix.length(), 4, "Size") != 0)
+                return false;
+            
+            if (prefix.length() + 4 < name.length())
+                specifier = std::stoi(name.substr(prefix.length() + 4));
+
+            return true;
+        };
+
+        if (match("Original"))
+        {
+            type = SlangShader::Uniform::Type::PassSize;
+            specifier = -1;
+            return true;
+        }    
+        else if (match("Source"))
+        {
+            type = SlangShader::Uniform::Type::PassSize;
+            specifier = pass - 1;
+            return true;
+        }
+        else if (match("Output"))
+        {
+            type = SlangShader::Uniform::Type::PassSize;
+            specifier = pass;
+            return true;
+        }
+        else if (match("OriginalHistory"))
+        {
+            type = SlangShader::Uniform::Type::PreviousFrameSize;
+            return true;
+        }
+        else if (match("PassOutput"))
+        {
+            type = SlangShader::Uniform::Type::PassSize;
+            return true;
+        }
+        else if (match("PassFeedback"))
+        {
+            type = SlangShader::Uniform::Type::PassFeedbackSize;
+            return true;
+        }
+        else if (match("User"))
+        {
+            type = SlangShader::Uniform::Type::LutSize;
+            return true;
+        }
+
+        for (size_t i = 0; i < passes.size(); i++)
+        {
+            if (match(passes[i].alias))
+            {
+                type = SlangShader::Uniform::Type::PassSize;
+                specifier = i;
+                return true;
+            }
+        }
+        
+        for (size_t i = 0; i < textures.size(); i++)
+        {
+            if (match(textures[i].id))
+            {
+                type = SlangShader::Uniform::Type::LutSize;
+                return true;
+            }
+        }
+    }
+
+    for (size_t i = 0; i < parameters.size(); i++)
+    {
+        if (name == parameters[i].id)
+        {
+            type = SlangShader::Uniform::Type::Parameter;
+            specifier = i;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/*
+    Introspect an individual shader pass, collecting external resource info
+    in order to build uniform blocks.
+*/
+bool SlangPreset::introspect_shader(SlangShader &shader, int pass, SlangShader::Stage stage)
+{
+    spirv_cross::CompilerGLSL cross(stage == SlangShader::Stage::Vertex ? shader.vertex_shader_spirv : shader.fragment_shader_spirv);
+
+    auto res = cross.get_shader_resources();
+
+    if (res.push_constant_buffers.size() > 1)
+    {
+        printf("%s: Too many push constant buffers.\n", shader.filename.c_str());
+        return false;
+    }
+    else if (res.uniform_buffers.size() > 1)
+    {
+        printf("%s: Too many uniform buffers.\n", shader.filename.c_str());
+        return false;
+    }
+
+    auto exists = [&shader](const SlangShader::Uniform &uniform) -> bool {
+        for (const auto &u : shader.uniforms)
+        {
+            if (u.block == uniform.block &&
+                u.offset == uniform.offset &&
+                u.specifier == uniform.specifier &&
+                u.type == uniform.type)
+            {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    if (res.push_constant_buffers.size() == 0)
+    {
+        shader.push_constant_block_size = 0;
+    }
+    else 
+    {
+        auto &pcb = res.push_constant_buffers[0];
+        auto &pcb_type = cross.get_type(pcb.base_type_id);
+        shader.push_constant_block_size = cross.get_declared_struct_size(pcb_type);
+
+        for (size_t i = 0; i < pcb_type.member_types.size(); i++)
+        {
+            auto name = cross.get_member_name(pcb.base_type_id, i);
+            auto offset = cross.get_member_decoration(pcb.base_type_id, i, spv::DecorationOffset);
+
+            SlangShader::Uniform::Type semantic_type;
+            int specifier;
+            if (match_buffer_semantic(name, pass, semantic_type, specifier))
+            {
+                SlangShader::Uniform uniform{ SlangShader::Uniform::Block::PushConstant,
+                                              offset,
+                                              semantic_type,
+                                              specifier };
+
+                if (!exists(uniform))
+                    shader.uniforms.push_back(uniform);
+            }
+            else 
+            {
+                printf("%s: Failed to match push constant semantic: \"%s\"\n", shader.filename.c_str(), name.c_str());
+            }
+        }
+    }
+
+    if (res.uniform_buffers.size() == 0)
+    {
+        shader.ubo_size = 0;
+    }
+    else 
+    {
+        auto &ubo = res.uniform_buffers[0];
+        auto &ubo_type = cross.get_type(ubo.base_type_id);
+        shader.ubo_size = cross.get_declared_struct_size(ubo_type);
+        shader.ubo_binding = cross.get_decoration(ubo.base_type_id, spv::DecorationBinding);
+
+        for (size_t i = 0; i < ubo_type.member_types.size(); i++)
+        {
+            auto name = cross.get_member_name(ubo.base_type_id, i);
+            auto offset = cross.get_member_decoration(ubo.base_type_id, i, spv::DecorationOffset);
+
+            SlangShader::Uniform::Type semantic_type;
+            int specifier;
+            if (match_buffer_semantic(name, pass, semantic_type, specifier))
+            {
+                SlangShader::Uniform uniform{ SlangShader::Uniform::Block::UBO,
+                                              offset,
+                                              semantic_type,
+                                              specifier };
+
+                if (!exists(uniform))
+                    shader.uniforms.push_back(uniform);
+            }
+            else 
+            {
+                printf("%s: Failed to match uniform buffer semantic: \"%s\"\n", shader.filename.c_str(), name.c_str());
+            }
+        }
+    }
+
+    if (res.sampled_images.size() == 0 && stage == SlangShader::Stage::Fragment)
+    {
+        printf("No sampled images found in fragment shader.\n");
+        return false;
+    }
+    
+    if (res.sampled_images.size() > 0 && stage == SlangShader::Stage::Vertex)
+    {
+        printf("Sampled image found in vertex shader.\n");
+        return false;
+    }
+
+    if (stage == SlangShader::Stage::Fragment)
+    {
+        for (auto &image : res.sampled_images)
+        {
+            SlangShader::Sampler::Type semantic_type;
+            int specifier;
+
+            if (match_sampler_semantic(image.name, pass, semantic_type, specifier))
+            {
+                int binding = cross.get_decoration(image.id, spv::DecorationBinding);
+                shader.samplers.push_back({ semantic_type, specifier, binding });
+            }
+            else 
+            {
+                printf("%s: Failed to match sampler semantic: \"%s\"\n", shader.filename.c_str(), image.name.c_str());
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/*
+    Introspect all of preset's shaders.
+*/
+bool SlangPreset::introspect()
+{ 
+    for (size_t i = 0; i < passes.size(); i++)
+    {
+        if (!introspect_shader(passes[i], i, SlangShader::Stage::Vertex))
+            return false;
+        if (!introspect_shader(passes[i], i, SlangShader::Stage::Fragment))
+            return false;
+    }
+
+    oldest_previous_frame = 0;
+    uses_feedback = false;
+    last_pass_uses_feedback = false;
+    
+    for (auto &p : passes)
+    {
+        for (auto &s : p.samplers)
+        {
+            if (s.type == SlangShader::Sampler::PreviousFrame && s.specifier > oldest_previous_frame)
+                oldest_previous_frame = s.specifier;
+            if (s.type == SlangShader::Sampler::PassFeedback)
+            {
+                uses_feedback = true;
+                if (s.specifier == (int)passes.size() - 1)
+                    last_pass_uses_feedback = true;
+            }
+        }
+    }
+
+    return true;
+}
+
+bool SlangPreset::save_to_file(std::string filename)
+{    
+    std::ofstream out(filename);
+    if (!out.is_open())
+        return false;
+
+    auto outs = [&](std::string key, std::string value) { out << key << " = \"" << value << "\"\n"; };
+    auto outb = [&](std::string key, bool value) { outs(key, value ? "true" : "false"); };
+    auto outa = [&](std::string key, auto value) { outs(key, to_string(value)); };
+
+    outa("shaders", passes.size());
+
+    for (size_t i = 0; i < passes.size(); i++)
+    {
+        auto &pass = passes[i];
+        auto indexed = [i](std::string str) { return str + to_string(i); };
+        outs(indexed("shader"), pass.filename);
+        outb(indexed("filter_linear"), pass.filter_linear);
+        outs(indexed("wrap_mode"), pass.wrap_mode);
+        outs(indexed("alias"), pass.alias);
+        outb(indexed("float_framebuffer"), pass.float_framebuffer);
+        outb(indexed("srgb_framebuffer"), pass.srgb_framebuffer);
+        outb(indexed("mipmap_input"), pass.mipmap_input);
+        outs(indexed("scale_type_x"), pass.scale_type_x);
+        outs(indexed("scale_type_y"), pass.scale_type_y);
+        outa(indexed("scale_x"), pass.scale_x);
+        outa(indexed("scale_y"), pass.scale_y);
+        outa(indexed("frame_count_mod"), pass.frame_count_mod);
+    }
+
+    if (parameters.size() > 0)
+    {
+        std::string parameter_list = "";
+        for (size_t i = 0; i < parameters.size(); i++)
+        {
+            parameter_list += parameters[i].id;
+            if (i < parameters.size() - 1)
+                parameter_list += ";";
+        }
+        outs("parameters", parameter_list);
+    }
+
+    for (auto &item : parameters)
+        outa(item.id, item.val);
+
+    if (textures.size() > 0)
+    {
+        std::string texture_list = "";
+        for (size_t i = 0; i < textures.size(); i++)
+        {
+            texture_list += textures[i].id;
+            if (i < textures.size() - 1)
+                texture_list += ";";
+        }
+        outs("textures", texture_list);
+    }
+
+    for (auto &item : textures)
+    {
+        outs(item.id, item.filename);
+        outb(item.id + "_linear", item.linear);
+        outs(item.id + "_wrap_mode", item.wrap_mode);
+        outb(item.id + "_mipmap", item.mipmap);
+    }
+
+    out.close();
+ 
+    return true;
+}

vulkan/slang_preset.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "slang_shader.hpp"
+#include "vulkan/vulkan_core.h"
+
+#include <string>
+#include <vector>
+
+struct SlangPreset
+{
+    SlangPreset();
+    ~SlangPreset();
+
+    void print();
+    bool load_preset_file(std::string filename);
+    bool introspect();
+    bool introspect_shader(SlangShader &s, int index, SlangShader::Stage stage);
+    bool match_buffer_semantic(const std::string &name, int pass, SlangShader::Uniform::Type &type, int &specifier);
+    bool match_sampler_semantic(const std::string &name, int pass, SlangShader::Sampler::Type &type, int &specifier);
+    void gather_parameters();
+    bool save_to_file(std::string filename);
+
+    struct Texture
+    {
+        std::string id;
+        std::string filename;
+        std::string wrap_mode;
+        bool mipmap;
+        bool linear;
+    };
+
+    std::vector<SlangShader> passes;
+    std::vector<Texture> textures;
+    std::vector<SlangShader::Parameter> parameters;
+    int oldest_previous_frame;
+    bool uses_feedback;
+    bool last_pass_uses_feedback;
+};

vulkan/slang_preset_ini.cpp

@@ -0,0 +1,145 @@
+#include "slang_preset_ini.hpp"
+#include "slang_helpers.hpp"
+#include <fstream>
+#include <cstring>
+#include <charconv>
+
+IniFile::IniFile()
+{
+}
+
+IniFile::~IniFile()
+{
+}
+
+static std::string trim_comments(std::string str)
+{
+    for (auto &comment : { "//", "#" })
+    {
+        auto location = str.rfind(comment);
+    
+        if (location != std::string::npos)
+            str = str.substr(0, location);
+    }
+
+    return trim(str);
+}
+
+static std::string trim_quotes(std::string str)
+{
+    if (str.length() > 1 && str.front() == '\"' && str.back() == '\"')
+        return str.substr(1, str.length() - 2);
+    return str;
+}
+
+bool IniFile::load_file(std::string filename)
+{
+    std::ifstream file;
+    file.open(filename);
+    if (!file.is_open())
+    {
+        printf("No file %s\n", filename.c_str());
+        return false;
+    }
+
+    std::string line;
+    while (1)
+    {
+        if (file.eof())
+            break;
+    
+        std::getline(file, line);
+
+        line = trim(line);
+
+        if (line.find("#reference") == 0)
+        {
+            std::string reference_path(trim_comments(line.substr(11)));
+            reference_path = trim_quotes(reference_path);
+            canonicalize(reference_path, filename);
+            printf("Loading file %s\n", reference_path.c_str());
+            if (!load_file(reference_path))
+            {
+                printf("Fail %s\n", reference_path.c_str());
+                return false;
+            }
+        }
+
+        line = trim_comments(line);
+
+        if (line.length() == 0)
+            continue;
+
+        auto equals = line.find('=');
+        if (equals != std::string::npos)
+        {
+            auto left_side = trim_quotes(trim(line.substr(0, equals)));
+            auto right_side = trim_quotes(trim(line.substr(equals + 1)));
+ 
+            keys.insert_or_assign(left_side, std::make_pair(right_side, filename));
+        }
+    }
+
+    return true;
+}
+
+std::string IniFile::get_string(std::string key, std::string default_value = "")
+{
+    auto it = keys.find(key);
+    if (it == keys.end())
+        return default_value;
+
+    return it->second.first;
+}
+
+int IniFile::get_int(std::string key, int default_value = 0)
+{
+    auto it = keys.find(key);
+    if (it == keys.end())
+        return default_value;
+
+    return std::stoi(it->second.first);
+}
+
+float IniFile::get_float(std::string key, float default_value = 0.0f)
+{
+   auto it = keys.find(key);
+   if (it == keys.end())
+        return default_value;
+
+    return std::stof(it->second.first);
+}
+
+std::string IniFile::get_source(std::string key)
+{
+    auto it = keys.find(key);
+    if (it == keys.end())
+        return "";
+    
+    return it->second.second;
+}
+
+bool IniFile::get_bool(std::string key, bool default_value = false)
+{
+   auto it = keys.find(key);
+   if (it == keys.end())
+        return default_value;
+
+    std::string lower = it->second.first;
+    for (auto &c : lower)
+        c = tolower(c);
+    
+    const char *true_strings[] = { "true", "1", "yes", "on"};
+    for (auto &s : true_strings)
+        if (lower == s)
+            return true;
+    return false;
+}
+
+bool IniFile::exists(std::string key)
+{
+    auto it = keys.find(key);
+    if (it == keys.end())
+        return false;
+    return true;
+}

vulkan/slang_preset_ini.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include <unordered_map>
+#include <string>
+
+struct IniFile
+{
+    IniFile();
+    ~IniFile();
+    bool load_file(std::string filename);
+    std::string get_string(std::string key, std::string default_string);
+    int get_int(std::string key, int default_int);
+    float get_float(std::string key, float default_float);
+    bool get_bool(std::string key, bool default_bool);
+    std::string get_source(std::string key);
+    bool exists(std::string key);
+    std::unordered_map<std::string, std::pair<std::string, std::string>> keys;
+};

vulkan/slang_preset_test.cpp

@@ -0,0 +1,25 @@
+#include "slang_preset.hpp"
+
+int main(int argc, char **argv)
+{
+    SlangPreset preset;
+
+    if (argc != 2)
+    {
+        printf("Usage %s shaderpreset\n", argv[0]);
+        return -1;
+    }
+
+    bool success = preset.load_preset_file(argv[1]);
+    if (!success)
+    {
+        printf("Failed to load %s\n", argv[1]);
+        return -1;
+    }
+    
+    preset.introspect();
+
+    preset.print();
+ 
+    return 0;
+}

vulkan/slang_shader.cpp

@@ -0,0 +1,274 @@
+#include "slang_shader.hpp"
+#include "slang_helpers.hpp"
+
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <sstream>
+#include <vector>
+#include <fstream>
+#include "../external/glslang/glslang/Public/ShaderLang.h"
+#include "../external/glslang/SPIRV/GlslangToSpv.h"
+#include "../external/glslang/StandAlone/ResourceLimits.h"
+
+using std::string;
+using std::vector;
+
+SlangShader::SlangShader()
+{
+    ubo_size = 0;
+}
+
+SlangShader::~SlangShader()
+{
+}
+
+/*
+    Recursively load shader file and included files into memory, applying
+    #include and #pragma directives. Will strip all directives except
+    #pragma stage.
+*/
+bool SlangShader::preprocess_shader_file(string filename, vector<string> &lines)
+{
+    std::ifstream stream(filename);
+
+    if (stream.fail())
+        return false;
+
+    string line;
+
+    while (std::getline(stream, line, '\n'))
+    {
+        std::string_view sv(line);
+        trim(sv);
+
+        if (sv.empty())
+            continue;
+        else if (sv.compare(0, 8, "#include") == 0)
+        {
+            sv.remove_prefix(8);
+            trim(sv);
+            if (sv.length() && sv[0] == '\"' && sv[sv.length() - 1] == '\"')
+            {
+                sv.remove_prefix(1);
+                sv.remove_suffix(1);
+                string include_file(sv);
+                canonicalize(include_file, filename);
+                preprocess_shader_file(include_file, lines);
+            }
+            else
+            {
+                printf("Syntax error: #include.\n");
+                return false;
+            }
+        }
+        else if (sv.compare(0, 17, "#pragma parameter") == 0)
+        {
+            Parameter p{};
+            sv.remove_prefix(17);
+
+            auto tokens = split_string_quotes(string{ sv });
+            if (tokens.size() < 5)
+            {
+                printf("Syntax error: #pragma parameter\n");
+                printf("%s\n", string{ sv }.c_str());
+                return false;
+            }
+
+            p.id = tokens[0];
+            p.name = tokens[1];
+            p.val = std::stof(tokens[2]);
+            p.min = std::stof(tokens[3]);
+            p.max = std::stof(tokens[4]);
+            if (tokens.size() >= 6)
+                p.step = std::stof(tokens[5]);
+
+            p.significant_digits = 0;
+            for (size_t i = 2; i < tokens.size(); i++)
+            {
+                int significant_digits = get_significant_digits(tokens[i]);
+                if (significant_digits > p.significant_digits)
+                    p.significant_digits = significant_digits;
+            }
+
+            parameters.push_back(p);
+
+            continue;
+        }
+        else if (sv.compare(0, 12, "#pragma name") == 0)
+        {
+            alias = sv.substr(13);
+        }
+        else if (sv.compare(0, 14, "#pragma format") == 0)
+        {
+            format = sv.substr(15);
+        }
+        else
+        {
+            if (sv.compare(0, 13, "#pragma stage") == 0)
+                pragma_stage_lines.push_back(lines.size());
+
+            lines.push_back(line);
+        }
+    }
+
+    return true;
+}
+
+/*
+    Use the #pragma stage lines to divide the file into separate vertex and
+    fragment shaders. Must have called preprocess beforehand.
+*/
+void SlangShader::divide_into_stages(const std::vector<std::string> &lines)
+{
+    enum
+    {
+        vertex,
+        fragment,
+        both
+    } stage;
+
+    stage = both;
+    std::ostringstream vertex_shader_stream;
+    std::ostringstream fragment_shader_stream;
+
+    auto p = pragma_stage_lines.begin();
+    for (size_t i = 0; i < lines.size(); i++)
+    {
+        if (p != pragma_stage_lines.end() && i == *p)
+        {
+            if (lines[i].find("vertex") != string::npos)
+                stage = vertex;
+            else if (lines[i].find("fragment") != string::npos)
+                stage = fragment;
+
+            p++;
+        }
+        else
+        {
+            if (stage == vertex || stage == both)
+                vertex_shader_stream << lines[i] << '\n';
+            if (stage == fragment || stage == both)
+                fragment_shader_stream << lines[i] << '\n';
+        }
+    }
+
+    vertex_shader_string = vertex_shader_stream.str();
+    fragment_shader_string = fragment_shader_stream.str();
+}
+
+/*
+    Load a shader file into memory, preprocess, divide and compile it to
+    SPIRV bytecode. Returns true on success.
+*/
+bool SlangShader::load_file(string new_filename)
+{
+    if (!new_filename.empty())
+        filename = new_filename;
+
+    pragma_stage_lines.clear();
+    vector<string> lines;
+    if (!preprocess_shader_file(filename, lines))
+    {
+        printf("Failed to load shader file: %s\n", filename.c_str());
+        return false;
+    }
+    divide_into_stages(lines);
+
+    if (!generate_spirv())
+        return false;
+
+    return true;
+}
+
+static void Initializeglslang()
+{
+    static bool ProcessInitialized = false;
+
+    if (!ProcessInitialized)
+    {
+        glslang::InitializeProcess();
+        ProcessInitialized = true;
+    }
+}
+
+std::vector<uint32_t> SlangShader::generate_spirv(std::string shader_string, std::string stage)
+{
+    Initializeglslang();
+    const EShMessages messages = (EShMessages)(EShMsgDefault | EShMsgVulkanRules | EShMsgSpvRules);
+    string debug;
+    auto forbid_includer = glslang::TShader::ForbidIncluder();
+
+    auto language = stage == "vertex" ? EShLangVertex : stage == "fragment" ? EShLangFragment : EShLangCompute;
+
+    glslang::TShader shaderTShader(language);
+
+    auto compile = [&debug, &forbid_includer](glslang::TShader &shader, string &shader_string, std::vector<uint32_t> &spirv) -> bool {
+        const char *source = shader_string.c_str();
+        shader.setStrings(&source, 1);
+        if (!shader.preprocess(&glslang::DefaultTBuiltInResource, 450, ENoProfile, false, false, messages, &debug, forbid_includer))
+            return false;
+        if (!shader.parse(&glslang::DefaultTBuiltInResource, 450, false, messages))
+            return false;
+
+        glslang::TProgram program;
+        program.addShader(&shader);
+        if (!program.link(messages))
+            return false;
+
+        glslang::GlslangToSpv(*program.getIntermediate(shader.getStage()), spirv);
+        return true;
+    };
+
+    std::vector<uint32_t> spirv;
+
+    if (!compile(shaderTShader, shader_string, spirv))
+    {
+        printf("%s\n%s\n%s\n", debug.c_str(), shaderTShader.getInfoLog(), shaderTShader.getInfoDebugLog());
+    }
+
+    return spirv;
+
+}
+
+/*
+    Generate SPIRV from separate preprocessed fragment and vertex shaders.
+    Must have called divide_into_stages beforehand. Returns true on success.
+*/
+bool SlangShader::generate_spirv()
+{
+    Initializeglslang();
+
+    const EShMessages messages = (EShMessages)(EShMsgDefault | EShMsgVulkanRules | EShMsgSpvRules | EShMsgDebugInfo | EShMsgAST | EShMsgEnhanced);
+    auto forbid_includer = glslang::TShader::ForbidIncluder();
+
+    glslang::TShader vertexTShader(EShLangVertex);
+    glslang::TShader fragmentTShader(EShLangFragment);
+
+    auto compile = [&forbid_includer](glslang::TShader &shader, string &shader_string, std::vector<uint32_t> &spirv) -> bool {
+        const char *source = shader_string.c_str();
+        shader.setStrings(&source, 1);
+        if (!shader.parse(&glslang::DefaultTBuiltInResource, 450, false, messages, forbid_includer))
+            return false;
+
+        glslang::TProgram program;
+        program.addShader(&shader);
+        if (!program.link(messages))
+            return false;
+
+        glslang::GlslangToSpv(*program.getIntermediate(shader.getStage()), spirv);
+        return true;
+    };
+
+    if (!compile(vertexTShader, vertex_shader_string, vertex_shader_spirv))
+    {
+        printf("%s\n%s\n", vertexTShader.getInfoLog(), vertexTShader.getInfoDebugLog());
+        return false;
+    }
+    if (!compile(fragmentTShader, fragment_shader_string, fragment_shader_spirv))
+    {
+        printf("%s\n%s\n", fragmentTShader.getInfoLog(), fragmentTShader.getInfoDebugLog());
+        return false;
+    }
+    return true;
+}

vulkan/slang_shader.hpp

@@ -0,0 +1,103 @@
+#pragma once
+#include <string>
+#include <vector>
+
+struct SlangShader
+{
+    struct Parameter 
+    {
+        std::string name;
+        std::string id;
+        float min;
+        float max;
+        float val;
+        float step;
+        int significant_digits;
+    };
+
+    struct Uniform
+    {
+        enum Block
+        {
+           UBO,
+           PushConstant,
+        };
+
+        enum Type
+        {
+            ViewportSize,
+            PreviousFrameSize,
+            PassSize,
+            PassFeedbackSize,
+            LutSize,
+            MVP,
+            FrameCount,
+            Parameter,
+            FrameDirection
+        };
+
+        Block block;
+        size_t offset;
+
+        Type type;
+        int specifier;
+    };
+
+    struct Sampler
+    {
+        enum Type
+        {
+            PreviousFrame,
+            Pass,
+            PassFeedback,
+            Lut
+        };
+
+        Type type;
+        int specifier;
+        int binding;
+    };
+
+    enum class Stage 
+    {
+        Vertex,
+        Fragment
+    };
+
+    SlangShader();
+    ~SlangShader();
+
+    bool preprocess_shader_file(std::string filename, std::vector<std::string> &lines);
+    void set_base_path(std::string filename);
+    bool load_file(std::string new_filename = "");
+    void divide_into_stages(const std::vector<std::string> &lines);
+    bool generate_spirv();
+    static std::vector<uint32_t> generate_spirv(std::string shader_string, std::string stage);
+
+    std::string filename;
+    std::string alias;
+    bool filter_linear;
+    bool mipmap_input;
+    bool float_framebuffer;
+    bool srgb_framebuffer;
+    int frame_count_mod;
+    std::string wrap_mode;
+    std::string scale_type_x;
+    std::string scale_type_y;
+    float scale_x;
+    float scale_y;
+    std::string format;
+    std::vector<Parameter> parameters;
+    std::vector<size_t> pragma_stage_lines;
+
+    std::string vertex_shader_string;
+    std::string fragment_shader_string;
+    std::vector<uint32_t> vertex_shader_spirv;
+    std::vector<uint32_t> fragment_shader_spirv;
+
+    size_t push_constant_block_size;
+    size_t ubo_size;
+    int ubo_binding;
+    std::vector<Uniform> uniforms;
+    std::vector<Sampler> samplers;
+};

vulkan/test.cpp

@@ -0,0 +1,80 @@
+#include <gtkmm.h>
+#include <gdk/gdkx.h>
+#include "vk2d.hpp"
+
+int main(int argc, char *argv[])
+{
+    XInitThreads();
+    auto application = Gtk::Application::create(argc, argv, "org.bearoso.vulkantest");
+
+    Gtk::Window window;
+    Gtk::Button button;
+    Gtk::DrawingArea drawingarea;
+    Gtk::VBox vbox;
+
+    window.set_title("Vulkan Test");
+    window.set_events(Gdk::EventMask::ALL_EVENTS_MASK);
+    button.set_label("Close");
+
+    vbox.pack_start(drawingarea, true, true, 0);
+    vbox.pack_start(button, false, false, 0);
+    vbox.set_spacing(5);
+    button.set_hexpand(false);
+    button.set_halign(Gtk::ALIGN_END);
+
+    window.add(vbox);
+    window.set_border_width(5);
+    vbox.show_all();
+
+    button.signal_clicked().connect([&] { 
+        window.close(); 
+    }); 
+
+    window.resize(640, 480);
+    window.show_all();
+
+    Window xid = gdk_x11_window_get_xid(drawingarea.get_window()->gobj());
+    Display *dpy = gdk_x11_display_get_xdisplay(drawingarea.get_display()->gobj());
+
+    vk2d vk2d;
+
+    vk2d.init_xlib_instance();
+    vk2d.attach(dpy, xid);
+    vk2d.init_device();
+
+    drawingarea.signal_configure_event().connect([&](GdkEventConfigure *event) {
+        vk2d.recreate_swapchain();
+        return false;
+    });
+
+    window.signal_key_press_event().connect([&](GdkEventKey *key) -> bool {
+        printf ("Key press %d\n", key->keyval);
+        return false;
+    }, false);
+
+    window.signal_key_release_event().connect([&](GdkEventKey *key) -> bool {
+        printf ("Key release %d\n", key->keyval);
+        return false;
+    }, false);
+
+    drawingarea.set_app_paintable(true);
+
+    drawingarea.signal_draw().connect([&](const Cairo::RefPtr<Cairo::Context> &context) -> bool {
+        return true;
+    });
+
+    auto id = Glib::signal_idle().connect([&]{
+        vk2d.draw();
+        vk2d.wait_idle();
+        return true;
+    });
+
+    window.signal_delete_event().connect([&](GdkEventAny *event) {
+        id.disconnect();
+        return false;
+    });
+
+    application->run(window);
+
+    return 0;
+}

vulkan/vk2d.cpp

@@ -0,0 +1,641 @@
+#include "vk2d.hpp"
+
+#include <glslang/Include/BaseTypes.h>
+#include <glslang/Public/ShaderLang.h>
+#include <glslang/SPIRV/GlslangToSpv.h>
+#include <glslang/Include/ResourceLimits.h>
+#include <vulkan/vulkan_core.h>
+
+static const char *vertex_shader = R"(
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) out vec3 fragColor;
+
+vec2 positions[3] = vec2[](
+    vec2(0.0, -0.5),
+    vec2(0.5, 0.5),
+    vec2(-0.5, 0.5)
+);
+
+vec3 colors[3] = vec3[](
+    vec3(1.0, 0.0, 0.0),
+    vec3(0.0, 1.0, 0.0),
+    vec3(0.0, 0.0, 1.0)
+);
+
+void main() {
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    fragColor = colors[gl_VertexIndex];
+}
+)";
+
+static const char *fragment_shader = R"(
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}
+)";
+
+bool vk2d::dispatcher_initialized = false;
+
+vk2d::vk2d()
+{
+    instance = nullptr;
+    surface = nullptr;
+
+    if (!dispatcher_initialized)
+    {
+        vk::DynamicLoader *dl = new vk::DynamicLoader;
+        PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = dl->getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
+        VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);
+        dispatcher_initialized = true;
+    }
+}
+
+vk2d::~vk2d()
+{
+    deinit();
+}
+
+bool vk2d::init_device()
+{
+    if (!instance || !surface)
+        return false;
+
+    choose_physical_device();
+    create_device();
+    create_sync_objects();
+    create_swapchain();
+    create_render_pass();
+    create_pipeline();
+    create_framebuffers();
+    create_command_buffers();
+
+    return true;
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+bool vk2d::init_xlib_instance()
+{
+    if (instance)
+        return true;
+
+    std::vector<const char *> extensions = { VK_KHR_XLIB_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_EXTENSION_NAME };
+    vk::ApplicationInfo ai({}, {}, {}, {}, VK_API_VERSION_1_0);
+    vk::InstanceCreateInfo ci({}, &ai, {}, extensions);
+
+    auto rv = vk::createInstance(ci);
+    if (rv.result != vk::Result::eSuccess)
+        return false;
+
+    instance = rv.value;
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(instance);
+    return true;
+}
+
+void vk2d::attach(Display *dpy, Window xid)
+{
+    if (surface)
+    {
+        instance.destroySurfaceKHR(surface);
+        surface = nullptr;
+    }
+
+    vk::XlibSurfaceCreateInfoKHR sci({}, dpy, xid);
+    auto rv = instance.createXlibSurfaceKHR(sci);
+    VK_CHECK(rv.result);
+    surface = rv.value;
+}
+#endif // VK_USE_PLATFORM_XLIB_KHR
+
+bool vk2d::create_instance()
+{
+    std::vector<const char *> extensions = { VK_KHR_XLIB_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_EXTENSION_NAME };
+
+    vk::ApplicationInfo ai({}, {}, {}, {}, VK_API_VERSION_1_1);
+    vk::InstanceCreateInfo ci({}, &ai, {}, {}, extensions.size(), extensions.data());
+
+    auto rv = vk::createInstance(ci);
+    VK_CHECK(rv.result);
+    instance = rv.value;
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(instance);
+    return true;
+}
+
+void vk2d::deinit()
+{
+    destroy_swapchain();
+
+    frame_queue.clear();
+
+    if (command_pool)
+        device.destroyCommandPool(command_pool);
+
+    if (device)
+        device.destroy();
+
+    if (surface)
+        instance.destroySurfaceKHR(surface);
+
+    if (instance)
+        instance.destroy();
+}
+
+void vk2d::destroy_swapchain()
+{
+    if (device)
+    {
+        VK_CHECK(device.waitIdle());
+    }
+    swapchain.framebuffers.clear();
+    swapchain.views.clear();
+
+    device.freeCommandBuffers(command_pool, swapchain.command_buffers);
+
+    if (graphics_pipeline)
+        device.destroyPipeline(graphics_pipeline);
+
+    if (render_pass)
+        device.destroyRenderPass(render_pass);
+
+    if (pipeline_layout)
+        device.destroyPipelineLayout(pipeline_layout);
+
+    if (swapchain.obj)
+    {
+        device.destroySwapchainKHR(swapchain.obj);
+        swapchain.obj = nullptr;
+    }
+}
+
+void vk2d::recreate_swapchain()
+{
+    frame_queue_index = 0;
+    destroy_swapchain();
+    create_swapchain();
+    create_render_pass();
+    create_pipeline();
+    create_framebuffers();
+    create_command_buffers();
+}
+
+void vk2d::choose_physical_device()
+{
+    if (!surface)
+        assert(0);
+
+    auto devices = instance.enumeratePhysicalDevices();
+    VK_CHECK(devices.result);
+    std::vector<vk::PhysicalDevice> candidates;
+    for (auto &d : devices.value)
+    {
+        auto extension_properties = d.enumerateDeviceExtensionProperties();
+        VK_CHECK(extension_properties.result);
+        bool presentable = false;
+        for (auto &e : extension_properties.value)
+        {
+            std::string name = e.extensionName;
+            if (name == VK_KHR_SWAPCHAIN_EXTENSION_NAME)
+            {
+                presentable = true;
+            }
+        }
+
+        if (!presentable)
+            continue;
+
+        auto queue_families = d.getQueueFamilyProperties();
+
+        for (size_t q = 0; q < queue_families.size(); q++)
+        {
+            if (queue_families[q].queueFlags & vk::QueueFlagBits::eGraphics)
+            {
+                graphics_queue_index = q;
+                presentable = true;
+                break;
+            }
+
+            presentable = false;
+        }
+
+        presentable = presentable && d.getSurfaceSupportKHR(graphics_queue_index, surface).value;
+
+        if (presentable)
+        {
+            printf("Using %s\n", (char *)d.getProperties().deviceName);
+            physical_device = d;
+            return;
+        }
+    }
+
+    physical_device = nullptr;
+    graphics_queue_index = -1;
+}
+
+void vk2d::wait_idle()
+{
+    if (device)
+    {
+        auto result = device.waitIdle();
+        VK_CHECK(result);
+    }
+}
+
+void vk2d::draw()
+{
+    auto &frame = frame_queue[frame_queue_index];
+    uint32_t next;
+
+    VK_CHECK(device.waitForFences(1, &frame.fence.get(), true, UINT64_MAX));
+    vk::ResultValue resval = device.acquireNextImageKHR(swapchain.obj, UINT64_MAX, frame.image_ready.get(), nullptr);
+
+    if (resval.result != vk::Result::eSuccess)
+    {
+        if (resval.result == vk::Result::eErrorOutOfDateKHR)
+        {
+            printf("Recreating swapchain\n");
+            recreate_swapchain();
+            return;
+        }
+
+        VK_CHECK(resval.result);
+        exit(1);
+    }
+    next = resval.value;
+
+    if (swapchain.frame_fence[next] > -1)
+    {
+        VK_CHECK(device.waitForFences(1, &frame_queue[next].fence.get(), true, UINT64_MAX));
+    }
+    swapchain.frame_fence[next] = frame_queue_index;
+
+    VK_CHECK(device.resetFences(1, &frame.fence.get()));
+
+    vk::PipelineStageFlags flags = vk::PipelineStageFlagBits::eColorAttachmentOutput;
+    vk::SubmitInfo submit_info(frame.image_ready.get(),
+                               flags,
+                               swapchain.command_buffers[next],
+                               frame.render_finished.get());
+
+    VK_CHECK(queue.submit(submit_info, frame.fence.get()));
+
+    vk::PresentInfoKHR present_info(frame.render_finished.get(), swapchain.obj, next, {});
+
+    VK_CHECK(queue.presentKHR(present_info));
+
+    frame_queue_index = (frame_queue_index + 1) % frame_queue_size;
+}
+
+void vk2d::create_device()
+{
+    float queue_priority = 1.0f;
+    std::vector<const char *> extension_names = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
+
+    vk::DeviceQueueCreateInfo dqci({}, graphics_queue_index, 1, &queue_priority);
+
+    vk::DeviceCreateInfo dci;
+    dci.setPEnabledExtensionNames(extension_names);
+
+    std::vector<vk::DeviceQueueCreateInfo> pqci = {dqci};
+    dci.setQueueCreateInfos(pqci);
+    device = physical_device.createDevice(dci).value;
+
+    queue = device.getQueue(graphics_queue_index, 0);
+
+    vk::CommandPoolCreateInfo command_pool_info({}, graphics_queue_index);
+    command_pool = device.createCommandPool(command_pool_info).value;
+}
+
+void vk2d::create_swapchain()
+{
+    if (!device || !surface)
+        assert(0);
+
+    vk::SurfaceCapabilitiesKHR surface_caps = physical_device.getSurfaceCapabilitiesKHR(surface).value;
+    swapchain.size = surface_caps.minImageCount;
+
+    vk::SwapchainCreateInfoKHR sci;
+    sci
+        .setSurface(surface)
+        .setMinImageCount(swapchain.size)
+        .setPresentMode(vk::PresentModeKHR::eFifo)
+        .setImageFormat(vk::Format::eB8G8R8A8Unorm)
+        .setImageExtent(surface_caps.currentExtent)
+        .setImageColorSpace(vk::ColorSpaceKHR::eSrgbNonlinear)
+        .setImageArrayLayers(1)
+        .setImageSharingMode(vk::SharingMode::eExclusive)
+        .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment)
+        .setCompositeAlpha(vk::CompositeAlphaFlagBitsKHR::eOpaque)
+        .setClipped(true);
+
+    if (swapchain.obj)
+        sci.setOldSwapchain(swapchain.obj);
+
+    swapchain.obj = device.createSwapchainKHR(sci).value;
+    swapchain.extents = surface_caps.currentExtent;
+    swapchain.images = device.getSwapchainImagesKHR(swapchain.obj).value;
+
+    swapchain.views.resize(swapchain.size);
+    for (size_t i = 0; i < swapchain.size; i++)
+    {
+        vk::ImageViewCreateInfo image_view_create_info;
+        image_view_create_info
+            .setImage(swapchain.images[i])
+            .setViewType(vk::ImageViewType::e2D)
+            .setFormat(vk::Format::eB8G8R8A8Unorm)
+            .setComponents(vk::ComponentMapping())
+            .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+        swapchain.views[i] = device.createImageViewUnique(image_view_create_info).value;
+    }
+
+    swapchain.frame_fence.resize(swapchain.size);
+    for (auto &f : swapchain.frame_fence)
+        f = -1;
+
+}
+
+void vk2d::create_sync_objects()
+{
+    frame_queue.resize(frame_queue_size);
+    for (size_t i = 0; i < frame_queue_size; i++)
+    {
+        vk::SemaphoreCreateInfo semaphore_create_info;
+        frame_queue[i].image_ready = device.createSemaphoreUnique(semaphore_create_info).value;
+        frame_queue[i].render_finished = device.createSemaphoreUnique(semaphore_create_info).value;
+
+        vk::FenceCreateInfo fence_create_info(vk::FenceCreateFlagBits::eSignaled);
+        frame_queue[i].fence = device.createFenceUnique(fence_create_info).value;
+    }
+    frame_queue_index = 0;
+}
+
+namespace glslang 
+{
+extern const TBuiltInResource DefaultTBuiltInResource;
+}
+
+void vk2d::create_shader_modules()
+{
+    glslang::InitializeProcess();
+    EShMessages message_flags = (EShMessages)(EShMsgDefault | EShMsgVulkanRules | EShMsgSpvRules);
+
+    glslang::TShader vertex(EShLangVertex);
+    glslang::TShader fragment(EShLangFragment);
+
+    vertex.setStrings(&vertex_shader, 1);
+    fragment.setStrings(&fragment_shader, 1);
+
+    vertex.parse(&glslang::DefaultTBuiltInResource, 450, true, message_flags);
+    fragment.parse(&glslang::DefaultTBuiltInResource, 450, true, message_flags);
+
+    glslang::TProgram vertex_program;
+    glslang::TProgram fragment_program;
+
+    vertex_program.addShader(&vertex);
+    fragment_program.addShader(&fragment);
+
+    vertex_program.link(message_flags);
+    fragment_program.link(message_flags);
+
+    auto log = [](const char *msg)
+    {
+        if (msg != nullptr && msg[0] != '\0')
+            puts(msg);
+    };
+    log(vertex_program.getInfoLog());
+    log(vertex_program.getInfoDebugLog());
+    log(fragment_program.getInfoLog());
+    log(fragment_program.getInfoDebugLog());
+
+    std::vector<uint32_t> vertex_spirv;
+    std::vector<uint32_t> fragment_spirv;
+
+    glslang::GlslangToSpv(*vertex_program.getIntermediate(EShLangVertex), vertex_spirv);
+    glslang::GlslangToSpv(*fragment_program.getIntermediate(EShLangFragment), fragment_spirv);
+
+    vk::ShaderModuleCreateInfo smci;
+    smci.setCode(vertex_spirv);
+    vertex_module = device.createShaderModule(smci).value;
+    smci.setCode(fragment_spirv);
+    fragment_module = device.createShaderModule(smci).value;
+}
+
+void vk2d::create_pipeline()
+{
+    create_shader_modules();
+
+    if (!vertex_module || !fragment_module)
+        assert(0);
+
+    vk::PipelineShaderStageCreateInfo vertex_ci;
+    vertex_ci
+        .setStage(vk::ShaderStageFlagBits::eVertex)
+        .setModule(vertex_module)
+        .setPName("main");
+
+    vk::PipelineShaderStageCreateInfo fragment_ci;
+    fragment_ci
+        .setStage(vk::ShaderStageFlagBits::eFragment)
+        .setModule(fragment_module)
+        .setPName("main");
+
+    std::vector<vk::PipelineShaderStageCreateInfo> stages = { vertex_ci, fragment_ci };
+
+    vk::PipelineVertexInputStateCreateInfo vertex_input_info;
+    vertex_input_info
+        .setVertexBindingDescriptionCount(0)
+        .setVertexAttributeDescriptionCount(0);
+
+    // Add Vertex attributes here
+
+    vk::PipelineInputAssemblyStateCreateInfo pipeline_input_assembly_info;
+    pipeline_input_assembly_info
+        .setTopology(vk::PrimitiveTopology::eTriangleList)
+        .setPrimitiveRestartEnable(false);
+
+    std::vector<vk::Viewport> viewports(1);
+    viewports[0]
+        .setX(0.0f)
+        .setY(0.0f)
+        .setWidth(swapchain.extents.width)
+        .setHeight(swapchain.extents.height)
+        .setMinDepth(0.0f)
+        .setMaxDepth(1.0f);
+    std::vector<vk::Rect2D> scissors(1);
+    scissors[0].extent = swapchain.extents;
+    scissors[0].offset = vk::Offset2D(0, 0);
+
+    vk::PipelineViewportStateCreateInfo pipeline_viewport_info;
+    pipeline_viewport_info
+        .setViewports(viewports)
+        .setScissors(scissors);
+
+    vk::PipelineRasterizationStateCreateInfo rasterizer_info;
+    rasterizer_info
+        .setCullMode(vk::CullModeFlagBits::eBack)
+        .setFrontFace(vk::FrontFace::eClockwise)
+        .setLineWidth(1.0f)
+        .setDepthClampEnable(false)
+        .setRasterizerDiscardEnable(false)
+        .setPolygonMode(vk::PolygonMode::eFill)
+        .setDepthBiasEnable(false)
+        .setRasterizerDiscardEnable(false);
+
+    vk::PipelineMultisampleStateCreateInfo multisample_info;
+    multisample_info
+        .setSampleShadingEnable(false)
+        .setRasterizationSamples(vk::SampleCountFlagBits::e1);
+
+    vk::PipelineDepthStencilStateCreateInfo depth_stencil_info;
+    depth_stencil_info.setDepthTestEnable(false);
+
+    vk::PipelineColorBlendAttachmentState blend_attachment_info;
+    blend_attachment_info
+        .setColorWriteMask(vk::ColorComponentFlagBits::eB |
+                           vk::ColorComponentFlagBits::eG |
+                           vk::ColorComponentFlagBits::eR |
+                           vk::ColorComponentFlagBits::eA)
+        .setBlendEnable(true)
+        .setColorBlendOp(vk::BlendOp::eAdd)
+        .setSrcColorBlendFactor(vk::BlendFactor::eSrcAlpha)
+        .setDstColorBlendFactor(vk::BlendFactor::eOneMinusSrcAlpha)
+        .setAlphaBlendOp(vk::BlendOp::eAdd)
+        .setSrcAlphaBlendFactor(vk::BlendFactor::eOne)
+        .setSrcAlphaBlendFactor(vk::BlendFactor::eZero);
+
+    vk::PipelineColorBlendStateCreateInfo blend_state_info;
+    blend_state_info
+        .setLogicOpEnable(false)
+        .setAttachmentCount(1)
+        .setPAttachments(&blend_attachment_info);
+
+    vk::PipelineDynamicStateCreateInfo dynamic_state_info;
+    dynamic_state_info.setDynamicStateCount(0);
+
+    vk::PipelineLayoutCreateInfo pipeline_layout_info;
+    pipeline_layout_info
+        .setSetLayoutCount(0)
+        .setPushConstantRangeCount(0);
+
+    pipeline_layout = device.createPipelineLayout(pipeline_layout_info).value;
+
+    vk::GraphicsPipelineCreateInfo pipeline_create_info;
+    pipeline_create_info
+        .setStageCount(2)
+        .setStages(stages)
+        .setPVertexInputState(&vertex_input_info)
+        .setPInputAssemblyState(&pipeline_input_assembly_info)
+        .setPViewportState(&pipeline_viewport_info)
+        .setPRasterizationState(&rasterizer_info)
+        .setPMultisampleState(&multisample_info)
+        .setPDepthStencilState(&depth_stencil_info)
+        .setPColorBlendState(&blend_state_info)
+        .setPDynamicState(&dynamic_state_info)
+        .setLayout(pipeline_layout)
+        .setRenderPass(render_pass)
+        .setSubpass(0);
+
+    vk::ResultValue<vk::Pipeline> result = device.createGraphicsPipeline(nullptr, pipeline_create_info);
+    graphics_pipeline = result.value;
+
+    device.destroyShaderModule(vertex_module);
+    device.destroyShaderModule(fragment_module);
+}
+
+void vk2d::create_render_pass()
+{
+    vk::AttachmentDescription attachment_description(
+        {}, 
+        vk::Format::eB8G8R8A8Unorm, 
+        vk::SampleCountFlagBits::e1, 
+        vk::AttachmentLoadOp::eClear, 
+        vk::AttachmentStoreOp::eStore, 
+        vk::AttachmentLoadOp::eLoad, 
+        vk::AttachmentStoreOp::eStore, 
+        vk::ImageLayout::eUndefined, 
+        vk::ImageLayout::ePresentSrcKHR);
+
+    vk::AttachmentReference attachment_reference(0, vk::ImageLayout::eColorAttachmentOptimal);
+    attachment_reference
+        .setAttachment(0)
+        .setLayout(vk::ImageLayout::eColorAttachmentOptimal);
+
+    vk::SubpassDependency subpass_dependency;
+    subpass_dependency
+        .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+        .setDstSubpass(0)
+        .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setSrcAccessMask(vk::AccessFlagBits(0))
+        .setDstStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setDstAccessMask(vk::AccessFlagBits::eColorAttachmentWrite);
+
+    vk::SubpassDescription subpass_description;
+    subpass_description
+        .setPipelineBindPoint(vk::PipelineBindPoint::eGraphics)
+        .setColorAttachments(attachment_reference);
+
+    vk::RenderPassCreateInfo render_pass_info(
+        {},
+        attachment_description,
+        subpass_description,
+        subpass_dependency);
+    render_pass = device.createRenderPass(render_pass_info).value;
+}
+
+void vk2d::create_framebuffers()
+{
+    swapchain.framebuffers.resize(swapchain.images.size());
+
+    for (size_t i = 0; i < swapchain.images.size(); i++)
+    {
+        vk::FramebufferCreateInfo fci;
+        std::vector<vk::ImageView> attachments = { swapchain.views[i].get() };
+        fci
+            .setAttachments(attachments)
+            .setLayers(1)
+            .setRenderPass(render_pass)
+            .setWidth(swapchain.extents.width)
+            .setHeight(swapchain.extents.height);
+
+        swapchain.framebuffers[i] = device.createFramebufferUnique(fci).value;
+    }
+
+}
+
+void vk2d::create_command_buffers()
+{
+    vk::CommandBufferAllocateInfo allocate_info;
+    allocate_info.setCommandBufferCount(swapchain.images.size());
+    allocate_info.setCommandPool(command_pool);
+    swapchain.command_buffers = device.allocateCommandBuffers(allocate_info).value;
+
+    for (size_t i = 0; i < swapchain.command_buffers.size(); i++)
+    {
+        auto &cb = swapchain.command_buffers[i];
+
+        VK_CHECK(cb.begin(vk::CommandBufferBeginInfo{}));
+
+        vk::ClearColorValue color;
+        color.setFloat32({ 0.0f, 1.0f, 1.0f, 0.0f});
+        vk::ClearValue clear_value(color);
+        vk::RenderPassBeginInfo rpbi;
+        rpbi.setRenderPass(render_pass);
+        rpbi.setFramebuffer(swapchain.framebuffers[i].get());
+        rpbi.setPClearValues(&clear_value);
+        rpbi.setClearValueCount(1);
+        rpbi.renderArea.setExtent(swapchain.extents);
+        rpbi.renderArea.setOffset({0, 0});
+        cb.beginRenderPass(rpbi, vk::SubpassContents::eInline);
+        cb.bindPipeline(vk::PipelineBindPoint::eGraphics, graphics_pipeline);
+        cb.draw(3, 1, 0, 0);
+        cb.endRenderPass();
+        VK_CHECK(cb.end());
+    }
+}

vulkan/vk2d.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "vulkan/vulkan.hpp"
+#include <fstream>
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#endif
+
+#define VK_CHECK(result) vk_check_result_function(result, __FILE__, __LINE__)
+inline void vk_check_result_function(vk::Result result, const char *file, int line)
+{
+    if (result != vk::Result::eSuccess)
+    {
+        printf("%s:%d  Vulkan error: %s\n", file, line, vk::to_string(result).c_str());
+    }
+}
+
+class vk2d
+{
+  public:
+    vk2d();
+    ~vk2d();
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    bool init_xlib_instance();
+    void attach(Display *dpy, Window xid);
+#endif
+
+    bool init_device();
+    void deinit();
+    bool create_instance();
+    void choose_physical_device();
+    void create_device();
+    void create_swapchain();
+    void create_sync_objects();
+    void create_shader_modules();
+    void create_pipeline();
+    void create_render_pass();
+    void create_framebuffers();
+    void create_command_buffers();
+    void recreate_swapchain();
+    void destroy_swapchain();
+    void wait_idle();
+    void draw();
+
+    vk::Instance instance;
+    vk::PhysicalDevice physical_device;
+    vk::SurfaceKHR surface;
+    vk::Pipeline graphics_pipeline;
+    vk::PipelineLayout pipeline_layout;
+    vk::RenderPass render_pass;
+
+    vk::ShaderModule vertex_module;
+    vk::ShaderModule fragment_module;
+
+    vk::Device device;
+    vk::Queue queue;
+    vk::CommandPool command_pool;
+    size_t graphics_queue_index;
+
+    struct frame_t {
+        vk::UniqueSemaphore render_finished;
+        vk::UniqueSemaphore image_ready;
+        vk::UniqueFence fence;
+    };
+
+    static const size_t frame_queue_size = 3;
+    size_t frame_queue_index;
+    std::vector<frame_t> frame_queue;
+
+    struct {
+        vk::SwapchainKHR obj;
+        vk::Extent2D extents;
+        std::vector<vk::Image> images;
+        std::vector<vk::UniqueImageView> views;
+        std::vector<vk::UniqueFramebuffer> framebuffers;
+        std::vector<vk::CommandBuffer> command_buffers;
+        std::vector<int> frame_fence;
+        size_t size;
+    } swapchain;
+
+    static bool dispatcher_initialized;
+};

vulkan/vk_mem_alloc_implementation.cpp

@@ -0,0 +1,2 @@
+#define VMA_IMPLEMENTATION
+#include "vk_mem_alloc.hpp"

vulkan/vulkan_context.cpp

@@ -0,0 +1,200 @@
+#include <exception>
+#include <cstring>
+#include <tuple>
+#include "vulkan_context.hpp"
+#include "vk_mem_alloc.hpp"
+#include "slang_shader.hpp"
+#include "vulkan/vulkan.hpp"
+
+namespace Vulkan
+{
+
+Context::Context()
+{
+    auto dl = new vk::DynamicLoader;
+    auto vkGetInstanceProcAddr =
+        dl->getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
+
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);
+}
+
+Context::~Context()
+{
+    if (!device)
+        return;
+    device.waitIdle();
+
+    swapchain = nullptr;
+
+    command_pool.reset();
+    descriptor_pool.reset();
+
+    allocator.destroy();
+
+    surface.reset();
+    device.waitIdle();
+
+    device.destroy();
+}
+
+bool Context::init(Display *dpy, Window xid, int preferred_device)
+{
+    if (instance)
+        return false;
+
+    xlib_display = dpy;
+    xlib_window = xid;
+
+    std::vector<const char *> extensions = { VK_KHR_XLIB_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_EXTENSION_NAME };
+    vk::ApplicationInfo application_info({}, {}, {}, {}, VK_API_VERSION_1_0);
+    vk::InstanceCreateInfo instance_create_info({}, &application_info, {}, extensions);
+
+    instance = vk::createInstanceUnique(instance_create_info);
+
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(instance.get());
+    surface = instance->createXlibSurfaceKHRUnique({ {}, xlib_display, xlib_window });
+
+    init_device(preferred_device);
+    init_vma();
+    init_command_pool();
+    init_descriptor_pool();
+
+    create_swapchain();
+
+    device.waitIdle();
+
+    return true;
+}
+
+bool Context::init_descriptor_pool()
+{
+    auto descriptor_pool_size = vk::DescriptorPoolSize{}
+        .setDescriptorCount(9)
+        .setType(vk::DescriptorType::eCombinedImageSampler);
+    auto descriptor_pool_create_info = vk::DescriptorPoolCreateInfo{}
+        .setPoolSizes(descriptor_pool_size)
+        .setMaxSets(20)
+        .setFlags(vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet);
+    descriptor_pool = device.createDescriptorPoolUnique(descriptor_pool_create_info);
+
+    return true;
+}
+
+bool Context::init_command_pool()
+{
+    vk::CommandPoolCreateInfo cpci({}, graphics_queue_family_index);
+    cpci.setFlags(vk::CommandPoolCreateFlagBits::eResetCommandBuffer);
+    command_pool = device.createCommandPoolUnique(cpci);
+
+    return true;
+}
+
+bool Context::init_device(int preferred_device)
+{
+    auto device_list = instance->enumeratePhysicalDevices();
+
+    auto find_device = [&]() -> vk::PhysicalDevice {
+        for (auto &d : device_list)
+        {
+            auto ep = d.enumerateDeviceExtensionProperties();
+            auto exists = std::find_if(ep.begin(), ep.end(), [](vk::ExtensionProperties &ext) {
+                return (std::string(ext.extensionName) == VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+            });
+
+            if (exists != ep.end())
+                return d;
+        }
+        return device_list[0];
+    };
+
+    if (preferred_device > 0)
+        physical_device = device_list[preferred_device];
+    else
+        physical_device = find_device();
+
+    physical_device.getProperties(&physical_device_props);
+
+    graphics_queue_family_index = UINT32_MAX;
+    auto queue_props = physical_device.getQueueFamilyProperties();
+    for (size_t i = 0; i < queue_props.size(); i++)
+    {
+        if (queue_props[i].queueFlags & vk::QueueFlagBits::eGraphics)
+            graphics_queue_family_index = i;
+    }
+
+    if (graphics_queue_family_index == UINT32_MAX)
+        return false;
+
+    std::vector<const char *> extension_names = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
+    std::vector<float> priorities { 1.0f };
+    vk::DeviceQueueCreateInfo dqci({}, graphics_queue_family_index, priorities);
+    vk::DeviceCreateInfo dci({}, dqci, {}, extension_names, {});
+    device = physical_device.createDevice(dci);
+    queue = device.getQueue(graphics_queue_family_index, 0);
+
+    auto surface_formats = physical_device.getSurfaceFormatsKHR(surface.get());
+    auto format = std::find_if(surface_formats.begin(), surface_formats.end(), [](vk::SurfaceFormatKHR &f) {
+        return (f.format == vk::Format::eB8G8R8A8Unorm);
+    });
+
+    if (format == surface_formats.end())
+        return false;
+
+    return true;
+}
+
+bool Context::init_vma()
+{
+    auto vulkan_functions = vma::VulkanFunctions{}
+        .setVkGetInstanceProcAddr(VULKAN_HPP_DEFAULT_DISPATCHER.vkGetInstanceProcAddr)
+        .setVkGetDeviceProcAddr(VULKAN_HPP_DEFAULT_DISPATCHER.vkGetDeviceProcAddr);
+
+    auto allocator_create_info = vma::AllocatorCreateInfo{}
+        .setDevice(device)
+        .setInstance(instance.get())
+        .setPhysicalDevice(physical_device)
+        .setPVulkanFunctions(&vulkan_functions);
+    allocator = vma::createAllocator(allocator_create_info);
+
+    return true;
+}
+
+bool Context::create_swapchain()
+{
+    wait_idle();
+    swapchain = std::make_unique<Swapchain>(device, physical_device, queue, surface.get(), command_pool.get());
+    return swapchain->create(3);
+}
+
+bool Context::recreate_swapchain()
+{
+    return swapchain->recreate();
+}
+
+void Context::wait_idle()
+{
+    if (device)
+        device.waitIdle();
+}
+
+vk::CommandBuffer Context::begin_cmd_buffer()
+{
+    vk::CommandBufferAllocateInfo command_buffer_allocate_info(command_pool.get(), vk::CommandBufferLevel::ePrimary, 1);
+    auto command_buffer = device.allocateCommandBuffers(command_buffer_allocate_info);
+    one_time_use_cmd = command_buffer[0];
+    one_time_use_cmd.begin({ vk::CommandBufferUsageFlagBits::eOneTimeSubmit });
+    return one_time_use_cmd;
+}
+
+void Context::end_cmd_buffer()
+{
+    one_time_use_cmd.end();
+    vk::SubmitInfo submit_info{};
+    submit_info.setCommandBuffers(one_time_use_cmd);
+    queue.submit(vk::SubmitInfo());
+    queue.waitIdle();
+    device.freeCommandBuffers(command_pool.get(), one_time_use_cmd);
+    one_time_use_cmd = nullptr;
+}
+
+} // namespace Vulkan

vulkan/vulkan_context.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "X11/Xlib.h"
+#include "vk_mem_alloc.hpp"
+#include "vulkan/vulkan.hpp"
+#include "vulkan_swapchain.hpp"
+#include <memory>
+#include <optional>
+
+namespace Vulkan
+{
+
+class Context
+{
+  public:
+    Context();
+    ~Context();
+    bool init(Display *dpy, Window xid, int preferred_device = 0);
+    bool create_swapchain();
+    bool recreate_swapchain();
+    void wait_idle();
+    vk::CommandBuffer begin_cmd_buffer();
+    void end_cmd_buffer();
+
+    vma::Allocator allocator;
+    vk::Device device;
+    vk::Queue queue;
+    vk::UniqueCommandPool command_pool;
+    vk::UniqueDescriptorPool descriptor_pool;
+    std::unique_ptr<Swapchain> swapchain;
+
+  private:
+    bool init_vma();
+    bool init_device(int preferred_device = 0);
+    bool init_command_pool();
+    bool init_descriptor_pool();
+    void create_vertex_buffer();
+
+    vk::UniquePipeline create_generic_pipeline();
+
+    Display *xlib_display;
+    Window xlib_window;
+
+    vk::UniqueInstance instance;
+    vk::PhysicalDevice physical_device;
+    vk::PhysicalDeviceProperties physical_device_props;
+    vk::UniqueSurfaceKHR surface;
+
+    uint32_t graphics_queue_family_index;
+
+    vk::CommandBuffer one_time_use_cmd;
+};
+
+} // namespace Vulkan

vulkan/vulkan_hpp_storage.cpp

@@ -0,0 +1,2 @@
+#include "vulkan/vulkan.hpp"
+VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE

vulkan/vulkan_pipeline_image.cpp

@@ -0,0 +1,266 @@
+#include "vulkan_pipeline_image.hpp"
+#include "slang_helpers.hpp"
+
+namespace Vulkan
+{
+
+PipelineImage::PipelineImage()
+{
+    image_width = 0;
+    image_height = 0;
+    device = nullptr;
+    command_pool = nullptr;
+    allocator = nullptr;
+    queue = nullptr;
+    image = nullptr;
+    current_layout = vk::ImageLayout::eUndefined;
+}
+
+PipelineImage::~PipelineImage()
+{
+    destroy();
+}
+
+void PipelineImage::init(vk::Device device_, vk::CommandPool command_, vk::Queue queue_, vma::Allocator allocator_)
+{
+    device = device_;
+    command_pool = command_;
+    allocator = allocator_;
+    queue = queue_;
+}
+
+void PipelineImage::init(Context *context)
+{
+    device = context->device;
+    command_pool = context->command_pool.get();
+    allocator = context->allocator;
+    queue = context->queue;
+}
+
+void PipelineImage::destroy()
+{
+    if (!device || !allocator)
+        return;
+
+    if (image_width != 0 || image_height != 0)
+    {
+        framebuffer.reset();
+        device.destroyImageView(image_view);
+        device.destroyImageView(mipless_view);
+        allocator.destroyImage(image, image_allocation);
+        image_width = image_height = 0;
+        image_view = nullptr;
+        image = nullptr;
+        image_allocation = nullptr;
+        current_layout = vk::ImageLayout::eUndefined;
+    }
+}
+
+void PipelineImage::generate_mipmaps(vk::CommandBuffer cmd)
+{
+    if (!mipmap)
+        return;
+
+    auto srr = [](unsigned int i) { return vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, i, 1, 0, 1); };
+    auto srl = [](unsigned int i) { return vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, i, 0, 1); };
+    auto image_memory_barrier = vk::ImageMemoryBarrier{}.setImage(image);
+
+    auto mipmap_levels = mipmap ? mipmap_levels_for_size(image_width, image_height) : 1;
+
+    // Transition base layer to readable format.
+    image_memory_barrier
+        .setImage(image)
+        .setOldLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+        .setNewLayout(vk::ImageLayout::eTransferSrcOptimal)
+        .setSrcAccessMask(vk::AccessFlagBits::eColorAttachmentWrite)
+        .setDstAccessMask(vk::AccessFlagBits::eTransferRead)
+        .setSubresourceRange(srr(0));
+
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eAllGraphics,
+                        vk::PipelineStageFlagBits::eTransfer,
+                        {}, {}, {}, image_memory_barrier);
+
+    int base_width = image_width;
+    int base_height = image_height;
+    int base_level = 0;
+    for (; base_level + 1 < mipmap_levels; base_level++)
+    {
+        // Transition base layer to readable format.
+        if (base_level > 0)
+        {
+            image_memory_barrier
+                .setImage(image)
+                .setOldLayout(vk::ImageLayout::eTransferDstOptimal)
+                .setNewLayout(vk::ImageLayout::eTransferSrcOptimal)
+                .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+                .setDstAccessMask(vk::AccessFlagBits::eTransferRead)
+                .setSubresourceRange(srr(base_level));
+
+            cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                                vk::PipelineStageFlagBits::eTransfer,
+                                {}, {}, {}, image_memory_barrier);
+        }
+
+        // Transition mipmap layer to writable
+        image_memory_barrier
+            .setImage(image)
+            .setOldLayout(vk::ImageLayout::eUndefined)
+            .setNewLayout(vk::ImageLayout::eTransferDstOptimal)
+            .setSrcAccessMask(vk::AccessFlagBits::eNone)
+            .setDstAccessMask(vk::AccessFlagBits::eTransferWrite)
+            .setSubresourceRange(srr(base_level + 1));
+
+        cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                            vk::PipelineStageFlagBits::eTransfer,
+                            {}, {}, {}, image_memory_barrier);
+
+        // Blit base layer to mipmap layer
+        int mipmap_width = base_width >> 1;
+        int mipmap_height = base_height >> 1;
+        if (mipmap_width < 1)
+            mipmap_width = 1;
+        if (mipmap_height < 1)
+            mipmap_height = 1;
+
+        auto blit = vk::ImageBlit{}
+            .setSrcOffsets({ vk::Offset3D(0, 0, 0), vk::Offset3D(base_width, base_height, 1) })
+            .setDstOffsets({ vk::Offset3D(0, 0, 0), vk::Offset3D(mipmap_width, mipmap_height, 1) })
+            .setSrcSubresource(srl(base_level))
+            .setDstSubresource(srl(base_level + 1));
+
+        base_width = mipmap_width;
+        base_height = mipmap_height;
+
+        cmd.blitImage(image, vk::ImageLayout::eTransferSrcOptimal, image, vk::ImageLayout::eTransferDstOptimal, blit, vk::Filter::eLinear);
+
+        // Transition base layer to shader readable
+        image_memory_barrier
+            .setOldLayout(vk::ImageLayout::eTransferSrcOptimal)
+            .setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+            .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+            .setDstAccessMask(vk::AccessFlagBits::eShaderRead)
+            .setSubresourceRange(srr(base_level));
+
+        cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                            vk::PipelineStageFlagBits::eFragmentShader,
+                            {}, {}, {}, image_memory_barrier);
+    }
+
+    // Transition final layer to shader readable
+    image_memory_barrier
+        .setOldLayout(vk::ImageLayout::eTransferDstOptimal)
+        .setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+        .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+        .setDstAccessMask(vk::AccessFlagBits::eShaderRead)
+        .setSubresourceRange(srr(base_level));
+
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                        vk::PipelineStageFlagBits::eFragmentShader,
+                        {}, {}, {}, image_memory_barrier);
+}
+
+void PipelineImage::barrier(vk::CommandBuffer cmd)
+{
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eAllGraphics,
+                        vk::PipelineStageFlagBits::eFragmentShader,
+                        {}, {}, {}, {});
+}
+
+void PipelineImage::clear(vk::CommandBuffer cmd)
+{
+    vk::ImageSubresourceRange subresource_range(vk::ImageAspectFlagBits::eColor, 0, VK_REMAINING_MIP_LEVELS, 0, 1);
+
+    auto image_memory_barrier = vk::ImageMemoryBarrier{}
+        .setImage(image)
+        .setSubresourceRange(subresource_range)
+        .setOldLayout(vk::ImageLayout::eUndefined)
+        .setNewLayout(vk::ImageLayout::eTransferDstOptimal)
+        .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite | vk::AccessFlagBits::eTransferRead)
+        .setDstAccessMask(vk::AccessFlagBits::eTransferWrite | vk::AccessFlagBits::eTransferRead);
+
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                        vk::PipelineStageFlagBits::eTransfer,
+                        {}, {}, {},
+                        image_memory_barrier);
+
+    vk::ClearColorValue color{};
+
+    color.setFloat32({ 0.0f, 0.0f, 0.0f, 1.0f });
+
+    cmd.clearColorImage(image,
+                        vk::ImageLayout::eTransferDstOptimal,
+                        color,
+                        subresource_range);
+
+    image_memory_barrier
+        .setOldLayout(vk::ImageLayout::eTransferDstOptimal)
+        .setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+        .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+        .setDstAccessMask(vk::AccessFlagBits::eShaderRead);
+
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                        vk::PipelineStageFlagBits::eFragmentShader,
+                        {}, {}, {},
+                        image_memory_barrier);
+    
+    current_layout = vk::ImageLayout::eShaderReadOnlyOptimal;
+}
+
+void PipelineImage::create(int width, int height, vk::Format fmt, vk::RenderPass renderpass, bool mipmap)
+{
+    assert(width + height);
+    assert(device && allocator);
+    this->mipmap = mipmap;
+    int mipmap_levels = mipmap ? mipmap_levels_for_size(width, height): 1;
+
+    format = fmt;
+
+    auto allocation_create_info = vma::AllocationCreateInfo{}
+        .setUsage(vma::MemoryUsage::eAuto);
+
+    auto image_create_info = vk::ImageCreateInfo{}
+        .setUsage(vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eSampled)
+        .setImageType(vk::ImageType::e2D)
+        .setExtent(vk::Extent3D(width, height, 1))
+        .setMipLevels(mipmap_levels)
+        .setArrayLayers(1)
+        .setFormat(format)
+        .setInitialLayout(vk::ImageLayout::eUndefined)
+        .setSamples(vk::SampleCountFlagBits::e1)
+        .setSharingMode(vk::SharingMode::eExclusive);
+
+    std::tie(image, image_allocation) = allocator.createImage(image_create_info, allocation_create_info);
+
+    auto subresource_range = vk::ImageSubresourceRange{}
+        .setAspectMask(vk::ImageAspectFlagBits::eColor)
+        .setBaseArrayLayer(0)
+        .setBaseMipLevel(0)
+        .setLayerCount(1)
+        .setLevelCount(mipmap_levels);
+
+    auto image_view_create_info = vk::ImageViewCreateInfo{}
+        .setImage(image)
+        .setViewType(vk::ImageViewType::e2D)
+        .setFormat(format)
+        .setComponents(vk::ComponentMapping())
+        .setSubresourceRange(subresource_range);
+
+    image_view = device.createImageView(image_view_create_info);
+
+    image_view_create_info.setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+    mipless_view = device.createImageView(image_view_create_info);
+
+    image_width = width;
+    image_height = height;
+
+    auto framebuffer_create_info = vk::FramebufferCreateInfo{}
+        .setAttachments(mipless_view)
+        .setWidth(width)
+        .setHeight(height)
+        .setRenderPass(renderpass)
+        .setLayers(1);
+
+    framebuffer = device.createFramebufferUnique(framebuffer_create_info);
+}
+
+} // namespace Vulkan

vulkan/vulkan_pipeline_image.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include "vulkan_context.hpp"
+
+namespace Vulkan
+{
+
+struct PipelineImage
+{
+    PipelineImage();
+    void init(vk::Device device, vk::CommandPool command, vk::Queue queue, vma::Allocator allocator);
+    void init(Vulkan::Context *context);
+    ~PipelineImage();
+
+    void create(int width, int height, vk::Format fmt, vk::RenderPass renderpass, bool mipmap = false);
+    void destroy();
+    void barrier(vk::CommandBuffer cmd);
+    void generate_mipmaps(vk::CommandBuffer cmd);
+    void clear(vk::CommandBuffer cmd);
+
+    vk::ImageView image_view;
+    vk::ImageView mipless_view;
+    vk::Image image;
+    vk::Format format;
+    vk::UniqueFramebuffer framebuffer;
+    vma::Allocation image_allocation;
+    vk::ImageLayout current_layout;
+    int image_width;
+    int image_height;
+    bool mipmap;
+
+    vk::Device device;
+    vk::Queue queue;
+    vk::CommandPool command_pool;
+    vma::Allocator allocator;
+};
+
+} // namespace Vulkan

vulkan/vulkan_shader_chain.cpp

@@ -0,0 +1,589 @@
+#include "vulkan_shader_chain.hpp"
+#include "slang_helpers.hpp"
+#include "fmt/format.h"
+#include "stb_image.h"
+#include "vulkan/vulkan_enums.hpp"
+
+namespace Vulkan
+{
+
+ShaderChain::ShaderChain(Context *context_)
+{
+    context = context_;
+    original_history_size = 3;
+    original_width = 0;
+    original_height = 0;
+    viewport_width = 0;
+    viewport_height = 0;
+    vertex_buffer = nullptr;
+    vertex_buffer_allocation = nullptr;
+    last_frame_index = 2;
+    current_frame_index = 0;
+}
+
+ShaderChain::~ShaderChain()
+{
+    if (context && context->device)
+    {
+        if (vertex_buffer)
+            context->allocator.destroyBuffer(vertex_buffer, vertex_buffer_allocation);
+        vertex_buffer = nullptr;
+        vertex_buffer_allocation = nullptr;
+    }
+    pipelines.clear();
+}
+
+void ShaderChain::construct_buffer_objects()
+{
+    for (size_t i = 0; i < pipelines.size(); i++)
+    {
+        auto &pipeline = *pipelines[i];
+        uint8_t *ubo_memory = nullptr;
+
+        if (pipeline.shader->ubo_size > 0)
+            ubo_memory = (uint8_t *)context->allocator.mapMemory(pipeline.uniform_buffer_allocation);
+
+        for (auto &uniform : pipeline.shader->uniforms)
+        {
+            void *location = 0;
+            const float MVP[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
+                                    0.0f, 1.0f, 0.0f, 0.0f,
+                                    0.0f, 0.0f, 1.0f, 0.0f,
+                                    0.0f, 0.0f, 0.0f, 1.0f };
+
+            std::string block;
+            switch (uniform.block)
+            {
+                case SlangShader::Uniform::UBO:
+                    location = &ubo_memory[uniform.offset];
+                    block = "uniform";
+                    break;
+                case SlangShader::Uniform::PushConstant:
+                    location = &pipeline.push_constants[uniform.offset];
+                    block = "push constant";
+                    break;
+            }
+
+            auto write_size = [&location](float width, float height) {
+                std::array<float, 4> size;
+                size[0] = width;
+                size[1] = height;
+                size[2] = 1.0f / size[0];
+                size[3] = 1.0f / size[1];
+                memcpy(location, size.data(), sizeof(float) * 4);
+            };
+
+            switch (uniform.type)
+            {
+                case SlangShader::Uniform::PassSize:
+                case SlangShader::Uniform::PassFeedbackSize: // TODO: Does this need to differ?
+
+                    if (uniform.specifier == -1)
+                    {
+                        write_size(original_width, original_height);
+                    }
+                    else
+                    {
+                        write_size(pipelines[uniform.specifier]->destination_width,
+                                   pipelines[uniform.specifier]->destination_height);
+                    }
+
+                    break;
+
+                case SlangShader::Uniform::ViewportSize:
+                    write_size(viewport_width, viewport_height);
+                    break;
+
+                case SlangShader::Uniform::PreviousFrameSize:
+                    if (original.size() > 1)
+                        write_size(original[1]->image_width, original[1]->image_height);
+                    else
+                        write_size(original_width, original_height);
+                    break;
+
+                case SlangShader::Uniform::LutSize:
+                    if (uniform.specifier < (int)lookup_textures.size())
+                        write_size(lookup_textures[uniform.specifier]->image_width, lookup_textures[uniform.specifier]->image_height);
+                    else
+                        write_size(1.0f, 1.0f);
+                    break;
+
+                case SlangShader::Uniform::MVP:
+                    memcpy(location, MVP, sizeof(float) * 16);
+                    break;
+
+                case SlangShader::Uniform::Parameter:
+                    if (uniform.specifier < (int)preset->parameters.size())
+                        memcpy(location, &preset->parameters[uniform.specifier].val, sizeof(float));
+                    break;
+
+                case SlangShader::Uniform::FrameCount:
+                    memcpy(location, &frame_count, sizeof(uint32_t));
+                    break;
+
+                case SlangShader::Uniform::FrameDirection:
+                    const int32_t frame_direction = 1;
+                    memcpy(location, &frame_direction, sizeof(int32_t));
+                    break;
+            }
+        }
+
+        if (pipeline.shader->ubo_size > 0)
+        {
+            context->allocator.unmapMemory(pipeline.uniform_buffer_allocation);
+            context->allocator.flushAllocation(pipeline.uniform_buffer_allocation, 0, pipeline.shader->ubo_size);
+        }
+    }
+}
+
+void ShaderChain::update_and_propagate_sizes(int original_width_new, int original_height_new, int viewport_width_new, int viewport_height_new)
+{
+    if (pipelines.empty())
+        return;
+
+    if (original_width == original_width_new &&
+        original_height == original_height_new &&
+        viewport_width == viewport_width_new &&
+        viewport_height == viewport_height_new)
+        return;
+
+    original_width = original_width_new;
+    original_height = original_height_new;
+    viewport_width = viewport_width_new;
+    viewport_height = viewport_height_new;
+
+    for (size_t i = 0; i < pipelines.size(); i++)
+    {
+        auto &p = pipelines[i];
+        if (i != 0)
+        {
+            p->source_width = pipelines[i - 1]->destination_width;
+            p->source_height = pipelines[i - 1]->destination_height;
+        }
+        else
+        {
+            p->source_width = original_width_new;
+            p->source_height = original_height_new;
+        }
+
+        if (p->shader->scale_type_x == "viewport")
+            p->destination_width = viewport_width * p->shader->scale_x;
+        else if (p->shader->scale_type_x == "absolute")
+            p->destination_width = p->shader->scale_x;
+        else
+            p->destination_width = p->source_width * p->shader->scale_x;
+
+        if (p->shader->scale_type_y == "viewport")
+            p->destination_height = viewport_height * p->shader->scale_y;
+        else if (p->shader->scale_type_y == "absolute")
+            p->destination_height = p->shader->scale_y;
+        else
+            p->destination_height = p->source_height * p->shader->scale_y;
+
+        if (i == pipelines.size() - 1)
+        {
+            p->destination_width = viewport_width;
+            p->destination_height = viewport_height;
+        }
+    }
+}
+
+bool ShaderChain::load_shader_preset(std::string filename)
+{
+    if (!ends_with(filename, ".slangp"))
+        fmt::print("Warning: loading preset without .slangp extension\n");
+
+    preset = std::make_unique<SlangPreset>();
+
+    if (!preset->load_preset_file(filename))
+    {
+        fmt::print("Couldn't load preset file: {}\n", filename);
+        return false;
+    }
+
+    if (!preset->introspect())
+    {
+        fmt::print("Failed introspection process in preset: {}\n", filename);
+        return false;
+    }
+
+    pipelines.clear();
+    pipelines.resize(preset->passes.size());
+
+    int num_ubos = 0;
+    int num_samplers = 0;
+
+    for (size_t i = 0; i < preset->passes.size(); i++)
+    {
+        auto &p = preset->passes[i];
+        pipelines[i] = std::make_unique<SlangPipeline>();
+        pipelines[i]->init(context, &p);
+        bool lastpass = (i == preset->passes.size() - 1);
+        if (!pipelines[i]->generate_pipeline(lastpass))
+        {
+            fmt::print("Couldn't create pipeline for shader: {}\n", p.filename);
+            return false;
+        }
+
+        for (auto &u : p.samplers)
+            if (u.type == SlangShader::Sampler::PreviousFrame)
+                if (u.specifier > (int)original_history_size)
+                    original_history_size = u.specifier;
+
+        if (p.ubo_size)
+            num_ubos++;
+        if (p.samplers.size() > 0)
+            num_samplers += p.samplers.size();
+    }
+    std::array<vk::DescriptorPoolSize, 2> descriptor_pool_sizes;
+    descriptor_pool_sizes[0]
+        .setType(vk::DescriptorType::eUniformBuffer)
+        .setDescriptorCount(num_ubos * 3);
+    descriptor_pool_sizes[1]
+        .setType(vk::DescriptorType::eCombinedImageSampler)
+        .setDescriptorCount(num_samplers * 3);
+
+    auto descriptor_pool_create_info = vk::DescriptorPoolCreateInfo{}
+        .setPoolSizes(descriptor_pool_sizes)
+        .setMaxSets(pipelines.size() * 3)
+        .setFlags(vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet);
+
+    descriptor_pool = context->device.createDescriptorPoolUnique(descriptor_pool_create_info);
+
+    for (auto &p : pipelines)
+        p->generate_frame_resources(descriptor_pool.get());
+
+    load_lookup_textures();
+
+    float vertex_data[] = { -1.0f, -3.0f, 0.0f, 1.0f, /* texcoords */   0.0, -1.0f,
+                             3.0f,  1.0f, 0.0f, 1.0f,                   2.0f, 1.0f,
+                            -1.0f,  1.0f, 0.0f, 1.0f,                   0.0f, 1.0f };
+
+    auto buffer_create_info = vk::BufferCreateInfo{}
+        .setSize(sizeof(vertex_data))
+        .setUsage(vk::BufferUsageFlagBits::eVertexBuffer);
+
+    auto allocation_create_info = vma::AllocationCreateInfo{}
+        .setFlags(vma::AllocationCreateFlagBits::eHostAccessSequentialWrite)
+        .setRequiredFlags(vk::MemoryPropertyFlagBits::eHostVisible);
+
+    std::tie(vertex_buffer, vertex_buffer_allocation) = context->allocator.createBuffer(buffer_create_info, allocation_create_info);
+
+    auto vertex_buffer_memory = context->allocator.mapMemory(vertex_buffer_allocation);
+    memcpy(vertex_buffer_memory, vertex_data, sizeof(vertex_data));
+    context->allocator.unmapMemory(vertex_buffer_allocation);
+    context->allocator.flushAllocation(vertex_buffer_allocation, 0, sizeof(vertex_data));
+
+    frame_count = 0;
+
+    return true;
+}
+
+void ShaderChain::update_framebuffers(vk::CommandBuffer cmd, int frame_num)
+{
+    size_t pass_count = pipelines.size() - 1;
+    if (preset->last_pass_uses_feedback)
+        pass_count++;
+
+    for (size_t i = 0; i < pass_count; i++)
+    {
+        bool mipmap = false;
+        if (i < pipelines.size() - 1)
+            mipmap = pipelines[i + 1]->shader->mipmap_input;
+        pipelines[i]->update_framebuffer(cmd, frame_num, mipmap);
+    }
+}
+
+void ShaderChain::update_descriptor_set(vk::CommandBuffer cmd, int pipe_num, int swapchain_index)
+{
+    auto &pipe = *pipelines[pipe_num];
+    auto &frame = pipe.frame[swapchain_index];
+
+    if (pipe.shader->ubo_size > 0)
+    {
+        auto descriptor_buffer_info = vk::DescriptorBufferInfo{}
+                .setBuffer(pipe.uniform_buffer)
+                .setOffset(0)
+                .setRange(pipe.shader->ubo_size);
+
+        auto write_descriptor_set = vk::WriteDescriptorSet{}
+            .setDescriptorType(vk::DescriptorType::eUniformBuffer)
+            .setBufferInfo(descriptor_buffer_info)
+            .setDstBinding(pipe.shader->ubo_binding)
+            .setDstSet(frame.descriptor_set.get());
+
+        context->device.updateDescriptorSets(write_descriptor_set, {});
+    }
+
+    auto descriptor_image_info = vk::DescriptorImageInfo{}
+        .setImageLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+
+    for (auto &sampler : pipe.shader->samplers)
+    {
+        if (sampler.type == SlangShader::Sampler::Lut)
+        {
+            descriptor_image_info
+                .setImageView(lookup_textures[sampler.specifier]->image_view)
+                .setSampler(lookup_textures[sampler.specifier]->sampler);
+        }
+        else if (sampler.type == SlangShader::Sampler::PassFeedback)
+        {
+            assert(sampler.specifier < (int)pipelines.size());
+            assert(sampler.specifier >= 0);
+            
+            if (!pipelines[sampler.specifier]->frame[last_frame_index].image.image)
+                update_framebuffers(cmd, last_frame_index);
+            auto &feedback_frame = pipelines[sampler.specifier]->frame[last_frame_index];
+            if (feedback_frame.image.current_layout == vk::ImageLayout::eUndefined)
+                feedback_frame.image.clear(cmd);
+
+            descriptor_image_info
+                .setImageView(pipelines[sampler.specifier]->frame[last_frame_index].image.image_view);
+            if (sampler.specifier == (int)pipelines.size() - 1)
+                descriptor_image_info.setSampler(pipelines[sampler.specifier]->sampler.get());
+            else
+                descriptor_image_info.setSampler(pipelines[sampler.specifier + 1]->sampler.get());;
+
+        }
+        else if (sampler.type == SlangShader::Sampler::Pass)
+        {
+            assert(sampler.specifier + 1 < (int)pipelines.size());
+            auto &sampler_to_use = pipelines[sampler.specifier + 1]->sampler.get();
+
+            if (sampler.specifier == -1)
+            {
+                descriptor_image_info
+                    .setSampler(sampler_to_use)
+                    .setImageView(original[0]->image_view);
+            }
+            else
+            {
+                descriptor_image_info
+                    .setSampler(sampler_to_use)
+                    .setImageView(pipelines[sampler.specifier]->frame[swapchain_index].image.image_view);
+            }
+        }
+        else if (sampler.type == SlangShader::Sampler::PreviousFrame)
+        {
+            int which_original = sampler.specifier;
+            if (which_original >= (int)original.size())
+                which_original = original.size() - 1;
+
+            assert(which_original > -1);
+
+            descriptor_image_info
+                .setSampler(pipelines[0]->sampler.get())
+                .setImageView(original[which_original]->image_view);
+        }
+
+        auto write_descriptor_set = vk::WriteDescriptorSet{}
+            .setDescriptorType(vk::DescriptorType::eCombinedImageSampler)
+            .setDstSet(frame.descriptor_set.get())
+            .setDstBinding(sampler.binding)
+            .setImageInfo(descriptor_image_info);
+        context->device.updateDescriptorSets(write_descriptor_set, {});
+    }
+}
+
+void ShaderChain::do_frame(uint8_t *data, int width, int height, int stride, vk::Format format, int viewport_x, int viewport_y, int viewport_width, int viewport_height)
+{
+    if (!context->swapchain->begin_frame())
+         return;
+
+    auto cmd = context->swapchain->get_cmd();
+
+    current_frame_index = context->swapchain->get_current_frame();
+
+    update_and_propagate_sizes(width, height, viewport_width, viewport_height);
+
+    update_framebuffers(cmd, current_frame_index);
+
+    upload_original(cmd, data, width, height, stride, format);
+
+    construct_buffer_objects();
+
+    for (size_t i = 0; i < pipelines.size(); i++)
+    {
+        auto &pipe = *pipelines[i];
+        auto &frame = pipe.frame[current_frame_index];
+
+        update_descriptor_set(cmd, i, current_frame_index);
+
+        vk::ClearValue value{};
+        value.color = { 0.0f, 0.0f, 0.0f, 1.0f };
+
+        auto render_pass_begin_info = vk::RenderPassBeginInfo{}
+            .setRenderPass(pipe.render_pass.get())
+            .setFramebuffer(frame.image.framebuffer.get())
+            .setRenderArea(vk::Rect2D({}, vk::Extent2D(frame.image.image_width, frame.image.image_height)))
+            .setClearValues(value);
+
+        if (i == pipelines.size() - 1)
+            context->swapchain->begin_render_pass();
+        else
+            cmd.beginRenderPass(render_pass_begin_info, vk::SubpassContents::eInline);
+
+        cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, pipe.pipeline.get());
+        cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipe.pipeline_layout.get(), 0, frame.descriptor_set.get(), {});
+        cmd.bindVertexBuffers(0, vertex_buffer, { 0 });
+        if (pipe.push_constants.size() > 0)
+            cmd.pushConstants(pipe.pipeline_layout.get(), vk::ShaderStageFlagBits::eAllGraphics, 0, pipe.push_constants.size(), pipe.push_constants.data());
+
+        if (i < pipelines.size() - 1)
+        {
+            cmd.setViewport(0, vk::Viewport(0, 0, pipe.destination_width, pipe.destination_height, 0.0f, 1.0f));
+            cmd.setScissor(0, vk::Rect2D({}, vk::Extent2D(pipe.destination_width, pipe.destination_height)));
+        }
+        else
+        {
+            cmd.setViewport(0, vk::Viewport(viewport_x, viewport_y, viewport_width, viewport_height, 0.0f, 1.0f));
+            cmd.setScissor(0, vk::Rect2D(vk::Offset2D(viewport_x, viewport_y), vk::Extent2D(viewport_width, viewport_height)));
+        }
+        cmd.draw(3, 1, 0, 0);
+
+        if (i < pipelines.size() - 1)
+        {
+            cmd.endRenderPass();
+        }
+        else
+        {
+            context->swapchain->end_render_pass();
+        }
+
+        frame.image.barrier(cmd);
+        if (i < pipelines.size() - 1)
+            frame.image.generate_mipmaps(cmd);
+
+        if (preset->last_pass_uses_feedback && i == pipelines.size() - 1)
+        {
+            std::array<vk::ImageMemoryBarrier, 2> image_memory_barrier{};
+            image_memory_barrier[0]
+                .setImage(frame.image.image)
+                .setOldLayout(vk::ImageLayout::eUndefined)
+                .setNewLayout(vk::ImageLayout::eTransferDstOptimal)
+                .setSrcAccessMask(vk::AccessFlagBits::eColorAttachmentWrite)
+                .setDstAccessMask(vk::AccessFlagBits::eTransferWrite)
+                .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+            image_memory_barrier[1]
+                .setImage(context->swapchain->get_image())
+                .setOldLayout(vk::ImageLayout::ePresentSrcKHR)
+                .setNewLayout(vk::ImageLayout::eTransferSrcOptimal)
+                .setSrcAccessMask(vk::AccessFlagBits::eColorAttachmentWrite)
+                .setDstAccessMask(vk::AccessFlagBits::eTransferRead)
+                .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+
+            cmd.pipelineBarrier(vk::PipelineStageFlagBits::eColorAttachmentOutput,
+                                vk::PipelineStageFlagBits::eTransfer,
+                                {}, {}, {}, image_memory_barrier);
+
+            auto image_blit = vk::ImageBlit{}
+                .setSrcOffsets({ vk::Offset3D(viewport_x, viewport_y, 0), vk::Offset3D(viewport_x + viewport_width, viewport_y + viewport_height, 1) })
+                .setDstOffsets({ vk::Offset3D(0, 0, 0), vk::Offset3D(viewport_width, viewport_height, 1) })
+                .setSrcSubresource(vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, 0, 0, 1))
+                .setDstSubresource(vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, 0, 0, 1));
+
+            cmd.blitImage(context->swapchain->get_image(), vk::ImageLayout::eTransferSrcOptimal, frame.image.image, vk::ImageLayout::eTransferDstOptimal, image_blit, vk::Filter::eNearest);
+
+            image_memory_barrier[0]
+                .setOldLayout(vk::ImageLayout::eTransferDstOptimal)
+                .setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+                .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+                .setDstAccessMask(vk::AccessFlagBits::eShaderRead)
+                .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+            image_memory_barrier[1]
+                .setOldLayout(vk::ImageLayout::eTransferSrcOptimal)
+                .setNewLayout(vk::ImageLayout::ePresentSrcKHR)
+                .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+                .setDstAccessMask(vk::AccessFlagBits::eMemoryRead)
+                .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+
+            cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                                vk::PipelineStageFlagBits::eAllGraphics,
+                                {}, {}, {}, image_memory_barrier);
+
+            frame.image.current_layout = vk::ImageLayout::eTransferDstOptimal;
+        }
+    }
+
+    context->swapchain->end_frame();
+
+    last_frame_index = current_frame_index;
+    frame_count++;
+}
+
+void ShaderChain::upload_original(vk::CommandBuffer cmd, uint8_t *data, int width, int height, int stride, vk::Format format)
+{
+    std::unique_ptr<Texture> texture;
+
+    auto create_texture = [&]() {
+        texture->create(width,
+                        height,
+                        format,
+                        wrap_mode_from_string(pipelines[0]->shader->wrap_mode),
+                        pipelines[0]->shader->filter_linear,
+                        true);
+    };
+
+    if (original.size() > original_history_size)
+    {
+        texture = std::move(original.back());
+        original.pop_back();
+        if (texture->image_width != width || texture->image_height != height || texture->format != format)
+        {
+            texture->destroy();
+            create_texture();
+        }
+    }
+    else
+    {
+        texture = std::make_unique<Texture>();
+        texture->init(context);
+        create_texture();
+    }
+
+    if (cmd)
+        texture->from_buffer(cmd, data, width, height, stride);
+    else
+        texture->from_buffer(data, width, height, stride);
+
+    original.push_front(std::move(texture));
+}
+
+void ShaderChain::upload_original(uint8_t *data, int width, int height, int stride, vk::Format format)
+{
+    upload_original(nullptr, data, width, height, stride, format);
+}
+
+bool ShaderChain::load_lookup_textures()
+{
+    if (preset->textures.size() < 1)
+        return true;
+
+    lookup_textures.clear();
+
+    for (auto &l : preset->textures)
+    {
+        int width, height, channels;
+        stbi_uc *bytes = stbi_load(l.filename.c_str(), &width, &height, &channels, 4);
+
+        if (!bytes)
+        {
+            fmt::print("Couldn't load look-up texture: {}\n", l.filename);
+            return false;
+        }
+
+        auto wrap_mode = wrap_mode_from_string(l.wrap_mode);
+
+        lookup_textures.push_back(std::make_unique<Texture>());
+        auto &t = lookup_textures.back();
+        t->init(context);
+        t->create(width, height, vk::Format::eR8G8B8A8Unorm, wrap_mode, l.linear, l.mipmap);
+        t->from_buffer(bytes, width, height);
+        t->discard_staging_buffer();
+        free(bytes);
+    }
+
+    return true;
+}
+
+} // namespace Vulkan

vulkan/vulkan_shader_chain.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "vulkan_context.hpp"
+#include "slang_preset.hpp"
+#include "vulkan_slang_pipeline.hpp"
+#include "vulkan_texture.hpp"
+#include <string>
+#include <deque>
+
+namespace Vulkan
+{
+
+class ShaderChain
+{
+  public:
+    ShaderChain(Context *context_);
+    ~ShaderChain();
+    bool load_shader_preset(std::string filename);
+    void update_and_propagate_sizes(int original_width_, int original_height_, int viewport_width_, int viewport_height_);
+    bool load_lookup_textures();
+    void do_frame(uint8_t *data, int width, int height, int stride, vk::Format format, int viewport_x, int viewport_y, int viewport_width, int viewport_height);
+    void upload_original(uint8_t *data, int width, int height, int stride, vk::Format format);
+    void upload_original(vk::CommandBuffer cmd, uint8_t *data, int width, int height, int stride, vk::Format format);
+    void construct_buffer_objects();
+    void update_framebuffers(vk::CommandBuffer cmd, int frame_num);
+    void update_descriptor_set(vk::CommandBuffer cmd, int pipe_num, int swapchain_index);
+
+    std::unique_ptr<SlangPreset> preset;
+    Context *context;
+    std::vector<std::unique_ptr<SlangPipeline>> pipelines;
+    size_t original_history_size;
+    uint32_t frame_count;
+    int original_width;
+    int original_height;
+    int viewport_width;
+    int viewport_height;
+    vk::UniqueDescriptorPool descriptor_pool;
+    std::vector<std::unique_ptr<Texture> > lookup_textures;
+    std::deque<std::unique_ptr<Texture> > original;
+    vk::Buffer vertex_buffer;
+    vma::Allocation vertex_buffer_allocation;
+    int current_frame_index;
+    int last_frame_index;
+};
+
+} // namespace Vulkan

vulkan/vulkan_slang_pipeline.cpp

@@ -0,0 +1,399 @@
+#include "vulkan_slang_pipeline.hpp"
+#include "slang_helpers.hpp"
+#include "fmt/format.h"
+#include <unordered_map>
+
+namespace Vulkan
+{
+
+static VkFormat format_string_to_format(std::string target, VkFormat default_format)
+{
+    struct
+    {
+        std::string string;
+        VkFormat format;
+    } formats[] = {
+        { "R8_UNORM", VK_FORMAT_R8_UNORM },
+        { "R8_UINT", VK_FORMAT_R8_UINT },
+        { "R8_SINT", VK_FORMAT_R8_SINT },
+        { "R8G8_UNORM", VK_FORMAT_R8G8_UNORM },
+        { "R8G8_UINT", VK_FORMAT_R8G8_UINT },
+        { "R8G8_SINT", VK_FORMAT_R8G8_SINT },
+        { "R8G8B8A8_UNORM", VK_FORMAT_R8G8B8A8_UNORM },
+        { "R8G8B8A8_UINT", VK_FORMAT_R8G8B8A8_UINT },
+        { "R8G8B8A8_SINT", VK_FORMAT_R8G8B8A8_SINT },
+        { "R8G8B8A8_SRGB", VK_FORMAT_R8G8B8A8_SRGB },
+
+        { "R16_UINT", VK_FORMAT_R16_UINT },
+        { "R16_SINT", VK_FORMAT_R16_SINT },
+        { "R16_SFLOAT", VK_FORMAT_R16_SFLOAT },
+        { "R16G16_UINT", VK_FORMAT_R16G16_UINT },
+        { "R16G16_SINT", VK_FORMAT_R16G16_SINT },
+        { "R16G16_SFLOAT", VK_FORMAT_R16G16_SFLOAT },
+        { "R16G16B16A16_UINT", VK_FORMAT_R16G16B16A16_UINT },
+        { "R16G16B16A16_SINT", VK_FORMAT_R16G16B16A16_SINT },
+        { "R16G16B16A16_SFLOAT", VK_FORMAT_R16G16B16A16_SFLOAT },
+
+        { "R32_UINT", VK_FORMAT_R32_UINT },
+        { "R32_SINT", VK_FORMAT_R32_SINT },
+        { "R32_SFLOAT", VK_FORMAT_R32_SFLOAT },
+        { "R32G32_UINT", VK_FORMAT_R32G32_UINT },
+        { "R32G32_SINT", VK_FORMAT_R32G32_SINT },
+        { "R32G32_SFLOAT", VK_FORMAT_R32G32_SFLOAT },
+        { "R32G32B32A32_UINT", VK_FORMAT_R32G32B32A32_UINT },
+        { "R32G32B32A32_SINT", VK_FORMAT_R32G32B32A32_SINT },
+        { "R32G32B32A32_SFLOAT", VK_FORMAT_R32G32B32A32_SFLOAT }
+    };
+
+    for (auto &f : formats)
+    {
+        if (f.string == target)
+            return f.format;
+    }
+
+    return default_format;
+}
+
+vk::SamplerAddressMode wrap_mode_from_string(std::string s)
+{
+    if (s == "clamp_to_border")
+        return vk::SamplerAddressMode::eClampToBorder;
+    if (s == "repeat")
+        return vk::SamplerAddressMode::eRepeat;
+    if (s == "mirrored_repeat")
+        return vk::SamplerAddressMode::eMirroredRepeat;
+
+    return vk::SamplerAddressMode::eClampToBorder;
+}
+
+SlangPipeline::SlangPipeline()
+{
+    device = nullptr;
+    shader = nullptr;
+    uniform_buffer = nullptr;
+    uniform_buffer_allocation = nullptr;
+    source_width = 0;
+    source_height = 0;
+    destination_width = 0;
+    destination_height = 0;
+}
+
+void SlangPipeline::init(Context *context_, SlangShader *shader_)
+{
+    this->context = context_;
+    this->device = context->device;
+    this->shader = shader_;
+}
+
+SlangPipeline::~SlangPipeline()
+{
+    device.waitIdle();
+
+    if (uniform_buffer)
+    {
+        context->allocator.destroyBuffer(uniform_buffer, uniform_buffer_allocation);
+    }
+
+    for (auto &f : frame)
+    {
+        if (f.descriptor_set)
+        {
+            f.descriptor_set.reset();
+            f.image.destroy();
+        }
+    }
+    pipeline.reset();
+    pipeline_layout.reset();
+    descriptor_set_layout.reset();
+    render_pass.reset();
+}
+
+bool SlangPipeline::generate_pipeline(bool lastpass)
+{
+    VkFormat backup_format = VK_FORMAT_R8G8B8A8_UNORM;
+    if (shader->srgb_framebuffer)
+        backup_format = VK_FORMAT_R8G8B8A8_SRGB;
+    if (shader->float_framebuffer)
+        backup_format = VK_FORMAT_R32G32B32A32_SFLOAT;
+    this->format = vk::Format(format_string_to_format(shader->format, backup_format));
+
+    auto attachment_description = vk::AttachmentDescription{}
+        .setFormat(this->format)
+        .setSamples(vk::SampleCountFlagBits::e1)
+        .setLoadOp(vk::AttachmentLoadOp::eClear)
+        .setStoreOp(vk::AttachmentStoreOp::eStore)
+        .setStencilLoadOp(vk::AttachmentLoadOp::eDontCare)
+        .setStencilStoreOp(vk::AttachmentStoreOp::eStore)
+        .setInitialLayout(vk::ImageLayout::eUndefined)
+        .setFinalLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+
+    auto attachment_reference = vk::AttachmentReference{}
+        .setAttachment(0)
+        .setLayout(vk::ImageLayout::eColorAttachmentOptimal);
+
+    std::array<vk::SubpassDependency, 2> subpass_dependency;
+    subpass_dependency[0]
+        .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+        .setDstSubpass(0)
+        .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setSrcAccessMask(vk::AccessFlagBits(0))
+        .setDstStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setDstAccessMask(vk::AccessFlagBits::eColorAttachmentWrite);
+
+    subpass_dependency[1]
+        .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+        .setDstSubpass(0)
+        .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setSrcAccessMask(vk::AccessFlagBits::eColorAttachmentWrite)
+        .setDstStageMask(vk::PipelineStageFlagBits::eFragmentShader)
+        .setDstAccessMask(vk::AccessFlagBits::eShaderRead);
+
+    auto subpass_description = vk::SubpassDescription{}
+        .setColorAttachments(attachment_reference)
+        .setPipelineBindPoint(vk::PipelineBindPoint::eGraphics);
+
+    auto render_pass_create_info = vk::RenderPassCreateInfo{}
+        .setSubpasses(subpass_description)
+        .setDependencies(subpass_dependency)
+        .setAttachments(attachment_description);
+
+    render_pass = device.createRenderPassUnique(render_pass_create_info);
+
+    auto vertex_module = device.createShaderModuleUnique({ {}, shader->vertex_shader_spirv });
+    auto fragment_module = device.createShaderModuleUnique({ {}, shader->fragment_shader_spirv });
+
+    auto vertex_ci = vk::PipelineShaderStageCreateInfo{}
+        .setStage(vk::ShaderStageFlagBits::eVertex)
+        .setModule(vertex_module.get())
+        .setPName("main");
+
+    auto fragment_ci = vk::PipelineShaderStageCreateInfo{}
+        .setStage(vk::ShaderStageFlagBits::eFragment)
+        .setModule(fragment_module.get())
+        .setPName("main");
+
+    std::vector<vk::PipelineShaderStageCreateInfo> stages = { vertex_ci, fragment_ci };
+
+    auto vertex_input_binding_description = vk::VertexInputBindingDescription{}
+        .setBinding(0)
+        .setInputRate(vk::VertexInputRate::eVertex)
+        .setStride(sizeof(float) * 6);
+
+    // Position 4x float
+    std::array<vk::VertexInputAttributeDescription, 2> vertex_attribute_description{};
+    vertex_attribute_description[0]
+        .setBinding(0)
+        .setFormat(vk::Format::eR32G32B32A32Sfloat)
+        .setOffset(0)
+        .setLocation(0);
+
+    // texcoord 2x float
+    vertex_attribute_description[1]
+        .setBinding(0)
+        .setFormat(vk::Format::eR32G32Sfloat)
+        .setOffset(sizeof(float) * 4)
+        .setLocation(1);
+
+    auto vertex_input_info = vk::PipelineVertexInputStateCreateInfo{}
+        .setVertexBindingDescriptions(vertex_input_binding_description)
+        .setVertexAttributeDescriptions(vertex_attribute_description);
+
+    auto pipeline_input_assembly_info = vk::PipelineInputAssemblyStateCreateInfo{}
+        .setTopology(vk::PrimitiveTopology::eTriangleList)
+        .setPrimitiveRestartEnable(false);
+
+    std::vector<vk::Viewport> viewports(1);
+    viewports[0]
+        .setX(0.0f)
+        .setY(0.0f)
+        .setWidth(256)
+        .setHeight(256)
+        .setMinDepth(0.0f)
+        .setMaxDepth(1.0f);
+    std::vector<vk::Rect2D> scissors(1);
+    scissors[0].extent.width = 256;
+    scissors[0].extent.height = 256;
+    scissors[0].offset = vk::Offset2D(0, 0);
+
+    auto pipeline_viewport_info = vk::PipelineViewportStateCreateInfo{}
+        .setViewports(viewports)
+        .setScissors(scissors);
+
+    auto rasterizer_info = vk::PipelineRasterizationStateCreateInfo{}
+        .setCullMode(vk::CullModeFlagBits::eBack)
+        .setFrontFace(vk::FrontFace::eClockwise)
+        .setLineWidth(1.0f)
+        .setDepthClampEnable(false)
+        .setRasterizerDiscardEnable(false)
+        .setPolygonMode(vk::PolygonMode::eFill)
+        .setDepthBiasEnable(false)
+        .setRasterizerDiscardEnable(false);
+
+    auto multisample_info = vk::PipelineMultisampleStateCreateInfo{}
+        .setSampleShadingEnable(false)
+        .setRasterizationSamples(vk::SampleCountFlagBits::e1);
+
+    auto depth_stencil_info = vk::PipelineDepthStencilStateCreateInfo{}
+        .setDepthTestEnable(false);
+
+    auto blend_attachment_info = vk::PipelineColorBlendAttachmentState{}
+        .setColorWriteMask(vk::ColorComponentFlagBits::eB |
+                           vk::ColorComponentFlagBits::eG |
+                           vk::ColorComponentFlagBits::eR |
+                           vk::ColorComponentFlagBits::eA)
+        .setBlendEnable(false)
+        .setColorBlendOp(vk::BlendOp::eAdd);
+        // .setSrcColorBlendFactor(vk::BlendFactor::eSrcAlpha)
+        // .setDstColorBlendFactor(vk::BlendFactor::eOneMinusSrcAlpha)
+        // .setAlphaBlendOp(vk::BlendOp::eAdd)
+        // .setSrcAlphaBlendFactor(vk::BlendFactor::eOne)
+        // .setSrcAlphaBlendFactor(vk::BlendFactor::eZero);
+
+    auto blend_state_info = vk::PipelineColorBlendStateCreateInfo{}
+        .setLogicOpEnable(false)
+        .setAttachments(blend_attachment_info);
+
+    std::vector<vk::DynamicState> states = { vk::DynamicState::eViewport, vk::DynamicState::eScissor };
+    vk::PipelineDynamicStateCreateInfo dynamic_state_info({}, states);
+
+    std::vector<vk::DescriptorSetLayoutBinding> descriptor_set_layout_bindings;
+    if (shader->ubo_size > 0)
+    {
+        vk::DescriptorSetLayoutBinding binding(
+            shader->ubo_binding,
+            vk::DescriptorType::eUniformBuffer,
+            1,
+            vk::ShaderStageFlagBits::eAllGraphics);
+
+        descriptor_set_layout_bindings.push_back(binding);
+    }
+
+    if (!shader->samplers.empty())
+    {
+        for (const auto &s : shader->samplers)
+        {
+            vk::DescriptorSetLayoutBinding binding(
+                s.binding,
+                vk::DescriptorType::eCombinedImageSampler,
+                1,
+                vk::ShaderStageFlagBits::eFragment);
+
+            descriptor_set_layout_bindings.push_back(binding);
+        }
+    }
+
+    auto dslci = vk::DescriptorSetLayoutCreateInfo{}
+        .setBindings(descriptor_set_layout_bindings);
+    descriptor_set_layout = device.createDescriptorSetLayoutUnique(dslci);
+
+    vk::PushConstantRange pcr(vk::ShaderStageFlagBits::eAllGraphics, 0, shader->push_constant_block_size);
+
+    auto pipeline_layout_info = vk::PipelineLayoutCreateInfo{}
+        .setSetLayoutCount(0)
+        .setSetLayouts(descriptor_set_layout.get());
+
+    if (shader->push_constant_block_size > 0)
+        pipeline_layout_info.setPushConstantRanges(pcr);
+
+    pipeline_layout = device.createPipelineLayoutUnique(pipeline_layout_info);
+
+    auto pipeline_create_info = vk::GraphicsPipelineCreateInfo{}
+        .setStageCount(2)
+        .setStages(stages)
+        .setPVertexInputState(&vertex_input_info)
+        .setPInputAssemblyState(&pipeline_input_assembly_info)
+        .setPViewportState(&pipeline_viewport_info)
+        .setPRasterizationState(&rasterizer_info)
+        .setPMultisampleState(&multisample_info)
+        .setPDepthStencilState(&depth_stencil_info)
+        .setPColorBlendState(&blend_state_info)
+        .setPDynamicState(&dynamic_state_info)
+        .setLayout(pipeline_layout.get())
+        .setRenderPass(render_pass.get())
+        .setSubpass(0);
+
+    if (lastpass)
+        pipeline_create_info.setRenderPass(context->swapchain->get_render_pass());
+
+    auto [result, pipeline] = device.createGraphicsPipelineUnique(nullptr, pipeline_create_info);
+
+    if (result != vk::Result::eSuccess)
+    {
+        fmt::print("Failed to create pipeline for shader: {}\n", shader->filename);
+        return false;
+    }
+
+    this->pipeline = std::move(pipeline);
+    return true;
+}
+
+void SlangPipeline::update_framebuffer(vk::CommandBuffer cmd, int num, bool mipmap)
+{
+   auto &image = frame[num].image;
+   if (image.image_width != destination_width || image.image_height != destination_height)
+   {
+        image.destroy();
+        image.create(destination_width, destination_height, format, render_pass.get(), mipmap);
+   }
+}
+
+bool SlangPipeline::generate_frame_resources(vk::DescriptorPool pool)
+{
+    for (auto &f : frame)
+    {
+        if (f.descriptor_set)
+        {
+            f.descriptor_set.reset();
+            f.image.destroy();
+        }
+
+        vk::DescriptorSetAllocateInfo descriptor_set_allocate_info(pool, descriptor_set_layout.get());
+
+        auto result = device.allocateDescriptorSetsUnique(descriptor_set_allocate_info);
+        f.descriptor_set = std::move(result[0]);
+    }
+
+    semaphore = device.createSemaphoreUnique({});
+
+    push_constants.resize(shader->push_constant_block_size);
+
+    if (shader->ubo_size > 0)
+    {
+        auto buffer_create_info = vk::BufferCreateInfo{}
+            .setSize(shader->ubo_size)
+            .setUsage(vk::BufferUsageFlagBits::eUniformBuffer);
+
+        auto allocation_create_info = vma::AllocationCreateInfo{}
+            .setFlags(vma::AllocationCreateFlagBits::eHostAccessSequentialWrite)
+            .setRequiredFlags(vk::MemoryPropertyFlagBits::eHostVisible);
+
+        std::tie(uniform_buffer, uniform_buffer_allocation) = context->allocator.createBuffer(buffer_create_info, allocation_create_info);
+    }
+    else
+    {
+        uniform_buffer = nullptr;
+        uniform_buffer_allocation = nullptr;
+    }
+
+    for (auto &f : frame)
+        f.image.init(context);
+
+    auto wrap_mode = wrap_mode_from_string(shader->wrap_mode);
+    auto filter = shader->filter_linear ? vk::Filter::eLinear : vk::Filter::eNearest;
+    auto sampler_create_info = vk::SamplerCreateInfo{}
+        .setAddressModeU(wrap_mode)
+        .setAddressModeV(wrap_mode)
+        .setAddressModeW(wrap_mode)
+        .setMagFilter(filter)
+        .setMinFilter(filter)
+        .setMipmapMode(vk::SamplerMipmapMode::eLinear)
+        .setMinLod(0.0f)
+        .setMaxLod(VK_LOD_CLAMP_NONE)
+        .setAnisotropyEnable(false);
+
+    sampler = device.createSamplerUnique(sampler_create_info);
+
+    return true;
+}
+
+} // namespace Vulkan

vulkan/vulkan_slang_pipeline.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include "vulkan/vulkan.hpp"
+#include "slang_shader.hpp"
+#include "vulkan_context.hpp"
+#include "vulkan_pipeline_image.hpp"
+
+namespace Vulkan
+{
+
+class SlangPipeline
+{
+  public:
+    SlangPipeline();
+    void init(Context *context_, SlangShader *shader_);
+    ~SlangPipeline();
+
+    bool generate_pipeline(bool lastpass = false);
+    bool generate_frame_resources(vk::DescriptorPool pool);
+    void update_framebuffer(vk::CommandBuffer, int frame_num, bool mipmap);
+
+    Context *context;
+    vk::Device device;
+    vk::Format format;
+    SlangShader *shader;
+    vk::UniqueRenderPass render_pass;
+    vk::UniqueDescriptorSetLayout descriptor_set_layout;
+    vk::UniquePipelineLayout pipeline_layout;
+    vk::UniquePipeline pipeline;
+    vk::UniqueSemaphore semaphore;
+    vk::UniqueSampler sampler;
+
+    struct 
+    {
+      vk::UniqueDescriptorSet descriptor_set;
+      PipelineImage image;
+    } frame[3];
+
+    vk::Buffer uniform_buffer;
+    vma::Allocation uniform_buffer_allocation;
+    std::vector<uint8_t> push_constants;
+
+    int source_width;
+    int source_height;
+    int destination_width;
+    int destination_height;
+};
+
+vk::SamplerAddressMode wrap_mode_from_string(std::string s);
+
+} // namespace Vulkan

vulkan/vulkan_swapchain.cpp

@@ -0,0 +1,300 @@
+#include "vulkan_swapchain.hpp"
+#include "vulkan/vulkan_structs.hpp"
+
+namespace Vulkan
+{
+
+Swapchain::Swapchain(vk::Device device_, vk::PhysicalDevice physical_device_, vk::Queue queue_, vk::SurfaceKHR surface_, vk::CommandPool command_pool_)
+    : surface(surface_),
+      command_pool(command_pool_),
+      physical_device(physical_device_),
+      queue(queue_)
+{
+    device = device_;
+    create_render_pass();
+}
+
+Swapchain::~Swapchain()
+{
+}
+
+bool Swapchain::set_vsync(bool new_setting)
+{
+    if (new_setting == vsync)
+        return false;
+
+    vsync = new_setting;
+    return true;
+}
+
+void Swapchain::create_render_pass()
+{
+    auto attachment_description = vk::AttachmentDescription{}
+        .setFormat(vk::Format::eB8G8R8A8Unorm)
+        .setSamples(vk::SampleCountFlagBits::e1)
+        .setLoadOp(vk::AttachmentLoadOp::eClear)
+        .setStoreOp(vk::AttachmentStoreOp::eStore)
+        .setStencilLoadOp(vk::AttachmentLoadOp::eDontCare)
+        .setStencilStoreOp(vk::AttachmentStoreOp::eStore)
+        .setInitialLayout(vk::ImageLayout::eUndefined)
+        .setFinalLayout(vk::ImageLayout::ePresentSrcKHR);
+
+    auto attachment_reference = vk::AttachmentReference{}
+        .setAttachment(0)
+        .setLayout(vk::ImageLayout::eColorAttachmentOptimal);
+
+    std::array<vk::SubpassDependency, 2> subpass_dependency{};
+    subpass_dependency[0]
+        .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+        .setDstSubpass(0)
+        .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setSrcAccessMask(vk::AccessFlagBits(0))
+        .setDstStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setDstAccessMask(vk::AccessFlagBits::eColorAttachmentWrite);
+    subpass_dependency[1]
+        .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+        .setDstSubpass(0)
+        .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+        .setSrcAccessMask(vk::AccessFlagBits::eColorAttachmentWrite)
+        .setDstStageMask(vk::PipelineStageFlagBits::eFragmentShader)
+        .setDstAccessMask(vk::AccessFlagBits::eShaderRead);
+
+
+    auto subpass_description = vk::SubpassDescription{}
+        .setColorAttachments(attachment_reference)
+        .setPipelineBindPoint(vk::PipelineBindPoint::eGraphics);
+
+    auto render_pass_create_info = vk::RenderPassCreateInfo{}
+        .setSubpasses(subpass_description)
+        .setDependencies(subpass_dependency)
+        .setAttachments(attachment_description);
+
+    render_pass = device.createRenderPassUnique(render_pass_create_info);
+}
+
+bool Swapchain::recreate()
+{
+    device.waitIdle();
+
+    return create(num_frames);
+}
+
+vk::Image Swapchain::get_image()
+{
+    return imageviewfbs[current_swapchain_image].image;
+}
+
+bool Swapchain::create(unsigned int desired_num_frames)
+{
+    frames.clear();
+    imageviewfbs.clear();
+
+    auto surface_capabilities = physical_device.getSurfaceCapabilitiesKHR(surface);
+
+    if (surface_capabilities.minImageCount > desired_num_frames)
+        num_frames = surface_capabilities.minImageCount;
+    else
+        num_frames = desired_num_frames;
+
+    extents = surface_capabilities.currentExtent;
+
+    if (extents.width <= 1 || extents.height <= 1)
+    {
+        // Surface is likely hidden
+        printf("Extents too small.\n");
+        return false;
+    }
+
+    auto swapchain_create_info = vk::SwapchainCreateInfoKHR{}
+        .setMinImageCount(num_frames)
+        .setImageFormat(vk::Format::eB8G8R8A8Unorm)
+        .setImageExtent(extents)
+        .setImageColorSpace(vk::ColorSpaceKHR::eSrgbNonlinear)
+        .setImageSharingMode(vk::SharingMode::eExclusive)
+        .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferSrc)
+        .setCompositeAlpha(vk::CompositeAlphaFlagBitsKHR::eOpaque)
+        .setClipped(true)
+        .setPresentMode(vsync ? vk::PresentModeKHR::eFifo : vk::PresentModeKHR::eImmediate)
+        .setSurface(surface)
+        .setImageArrayLayers(1);
+
+    if (swapchain)
+        swapchain_create_info.setOldSwapchain(swapchain.get());
+
+    swapchain = device.createSwapchainKHRUnique(swapchain_create_info);
+
+    auto swapchain_images = device.getSwapchainImagesKHR(swapchain.get());
+    vk::CommandBufferAllocateInfo command_buffer_allocate_info(command_pool, vk::CommandBufferLevel::ePrimary, num_frames);
+    auto command_buffers = device.allocateCommandBuffersUnique(command_buffer_allocate_info);
+
+    if (imageviewfbs.size() > num_frames)
+        num_frames = imageviewfbs.size();
+
+    frames.resize(num_frames);
+    imageviewfbs.resize(num_frames);
+
+    vk::FenceCreateInfo fence_create_info(vk::FenceCreateFlagBits::eSignaled);
+
+    for (unsigned int i = 0; i < num_frames; i++)
+    {
+        // Create frame queue resources
+        auto &frame = frames[i];
+        frame.command_buffer = std::move(command_buffers[i]);
+        frame.fence = device.createFenceUnique(fence_create_info);
+        frame.acquire = device.createSemaphoreUnique({});
+        frame.complete = device.createSemaphoreUnique({});
+    }
+    current_frame = 0;
+
+    for (unsigned int i = 0; i < num_frames; i++)
+    {
+        // Create resources associated with swapchain images
+        auto &image = imageviewfbs[i];
+        image.image = swapchain_images[i];
+        auto image_view_create_info = vk::ImageViewCreateInfo{}
+            .setImage(swapchain_images[i])
+            .setViewType(vk::ImageViewType::e2D)
+            .setFormat(vk::Format::eB8G8R8A8Unorm)
+            .setComponents(vk::ComponentMapping())
+            .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+        image.image_view = device.createImageViewUnique(image_view_create_info);
+
+        auto framebuffer_create_info = vk::FramebufferCreateInfo{}
+            .setAttachments(image.image_view.get())
+            .setWidth(extents.width)
+            .setHeight(extents.height)
+            .setLayers(1)
+            .setRenderPass(render_pass.get());
+        image.framebuffer = device.createFramebufferUnique(framebuffer_create_info);
+    }
+
+    current_swapchain_image = 0;
+
+    return true;
+}
+
+bool Swapchain::begin_frame()
+{
+    if (extents.width < 1 || extents.height < 1)
+    {
+        printf ("Extents too small\n");
+        return false;
+    }
+
+    auto &frame = frames[current_frame];
+
+    auto result = device.waitForFences(frame.fence.get(), true, 33000000);
+    if (result != vk::Result::eSuccess)
+    {
+        printf("Failed fence\n");
+        return false;
+    }
+
+    auto result_value = device.acquireNextImageKHR(swapchain.get(), 33000000, frame.acquire.get());
+    if (result_value.result == vk::Result::eErrorOutOfDateKHR ||
+        result_value.result == vk::Result::eSuboptimalKHR)
+    {
+        recreate();
+        return begin_frame();
+    }
+
+    if (result_value.result != vk::Result::eSuccess)
+    {
+        printf ("Random failure %d\n", result_value.result);
+        return false;
+    }
+
+    device.resetFences(frame.fence.get());
+    current_swapchain_image = result_value.value;
+
+    vk::CommandBufferBeginInfo command_buffer_begin_info(vk::CommandBufferUsageFlags{vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
+    frame.command_buffer->begin(command_buffer_begin_info);
+
+    return true;
+}
+
+bool Swapchain::end_frame()
+{
+    auto &frame = frames[current_frame];
+    frame.command_buffer->end();
+
+    vk::PipelineStageFlags flags = vk::PipelineStageFlagBits::eColorAttachmentOutput;
+    vk::SubmitInfo submit_info(
+        frame.acquire.get(),
+        flags,
+        frame.command_buffer.get(),
+        frame.complete.get());
+
+    queue.submit(submit_info, frame.fence.get());
+
+    auto present_info = vk::PresentInfoKHR{}
+        .setWaitSemaphores(frames[current_frame].complete.get())
+        .setSwapchains(swapchain.get())
+        .setImageIndices(current_swapchain_image);
+
+    auto result = queue.presentKHR(present_info);
+
+    current_frame = (current_frame + 1) % num_frames;
+
+    if (result != vk::Result::eSuccess)
+        return false;
+    return true;
+}
+
+vk::Framebuffer Swapchain::get_framebuffer()
+{
+    return imageviewfbs[current_swapchain_image].framebuffer.get();
+}
+
+vk::CommandBuffer &Swapchain::get_cmd()
+{
+    return frames[current_frame].command_buffer.get();
+}
+
+void Swapchain::begin_render_pass()
+{
+    vk::ClearColorValue colorval;
+    colorval.setFloat32({ 0.0f, 0.0f, 0.0f, 1.0f });
+    vk::ClearValue value;
+    value.setColor(colorval);
+
+    auto render_pass_begin_info = vk::RenderPassBeginInfo{}
+        .setRenderPass(render_pass.get())
+        .setFramebuffer(imageviewfbs[current_swapchain_image].framebuffer.get())
+        .setRenderArea(vk::Rect2D({}, extents))
+        .setClearValues(value);
+    get_cmd().beginRenderPass(render_pass_begin_info, vk::SubpassContents::eInline);
+}
+
+void Swapchain::end_render_pass()
+{
+    get_cmd().endRenderPass();
+}
+
+unsigned int Swapchain::get_current_frame()
+{
+    return current_frame;
+}
+
+bool Swapchain::wait_on_frame(int frame_num)
+{
+    auto result = device.waitForFences(frames[frame_num].fence.get(), true, 33000000);
+    return (result == vk::Result::eSuccess);
+}
+
+vk::Extent2D Swapchain::get_extents()
+{
+    return extents;
+}
+
+vk::RenderPass &Swapchain::get_render_pass()
+{
+    return render_pass.get();
+}
+
+unsigned int Swapchain::get_num_frames()
+{
+    return num_frames;
+}
+
+} // namespace Vulkan

vulkan/vulkan_swapchain.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "vulkan/vulkan.hpp"
+#include "vulkan/vulkan_handles.hpp"
+#include "vulkan/vulkan_structs.hpp"
+
+namespace Vulkan
+{
+
+class Swapchain
+{
+  public:
+    Swapchain(vk::Device device,
+              vk::PhysicalDevice physical_device,
+              vk::Queue queue,
+              vk::SurfaceKHR surface,
+              vk::CommandPool command_pool);
+    ~Swapchain();
+    bool create(unsigned int num_frames);
+    bool recreate();
+    bool begin_frame();
+    void begin_render_pass();
+    void end_render_pass();
+    bool wait_on_frame(int frame_num);
+    bool end_frame();
+    // Returns true if vsync setting was changed, false if it was the same
+    bool set_vsync(bool on);
+
+    vk::Image get_image();
+    vk::Framebuffer get_framebuffer();
+    vk::CommandBuffer &get_cmd();
+    unsigned int get_current_frame();
+    vk::Extent2D get_extents();
+    vk::RenderPass &get_render_pass();
+    unsigned int get_num_frames();
+
+  private:
+
+    void create_render_pass();
+
+    struct Frame
+    {
+        vk::UniqueFence fence;
+        vk::UniqueSemaphore acquire;
+        vk::UniqueSemaphore complete;
+        vk::UniqueCommandBuffer command_buffer;
+    };
+
+    struct ImageViewFB
+    {
+        vk::Image image;
+        vk::UniqueImageView image_view;
+        vk::UniqueFramebuffer framebuffer;
+    };
+
+    vk::UniqueSwapchainKHR swapchain;
+    vk::Extent2D extents;
+
+    vk::UniqueRenderPass render_pass;
+
+    unsigned int current_frame = 0;
+    unsigned int current_swapchain_image = 0;
+    unsigned int num_frames = 0;
+    bool vsync = true;
+    std::vector<Frame> frames;
+    std::vector<ImageViewFB> imageviewfbs;
+
+    vk::Device device;
+    vk::SurfaceKHR surface;
+    vk::CommandPool command_pool;
+    vk::PhysicalDevice physical_device;
+    vk::Queue queue;
+};
+
+} // namespace Vulkan

vulkan/vulkan_texture.cpp

@@ -0,0 +1,307 @@
+#include "vulkan_texture.hpp"
+#include "vulkan/vulkan_enums.hpp"
+#include "slang_helpers.hpp"
+
+namespace Vulkan
+{
+
+Texture::Texture()
+{
+    image_width = 0;
+    image_height = 0;
+    buffer_size = 0;
+    device = nullptr;
+    command_pool = nullptr;
+    allocator = nullptr;
+    queue = nullptr;
+    buffer = nullptr;
+    image = nullptr;
+    sampler = nullptr;
+}
+
+Texture::~Texture()
+{
+    destroy();
+}
+
+void Texture::destroy()
+{
+    if (!device || !allocator)
+        return;
+
+    if (sampler)
+    {
+        device.destroySampler(sampler);
+        sampler = nullptr;
+    }
+
+    if (image_width != 0 || image_height != 0)
+    {
+        device.destroyImageView(image_view);
+        allocator.destroyImage(image, image_allocation);
+        image_width = image_height = 0;
+        image_view = nullptr;
+        image = nullptr;
+        image_allocation = nullptr;
+    }
+
+    if (buffer_size != 0)
+    {
+        allocator.destroyBuffer(buffer, buffer_allocation);
+        buffer_size = 0;
+        buffer = nullptr;
+        buffer_allocation = nullptr;
+    }
+}
+
+void Texture::init(vk::Device device_, vk::CommandPool command_, vk::Queue queue_, vma::Allocator allocator_)
+{
+    device = device_;
+    command_pool = command_;
+    allocator = allocator_;
+    queue = queue_;
+}
+
+void Texture::init(Context *context)
+{
+    device = context->device;
+    command_pool = context->command_pool.get();
+    allocator = context->allocator;
+    queue = context->queue;
+}
+
+void Texture::from_buffer(vk::CommandBuffer cmd,
+                          uint8_t *buffer,
+                          int width,
+                          int height,
+                          int byte_stride)
+{
+    if (image_width != width || image_height != height)
+    {
+        destroy();
+        create(width, height, format, wrap_mode, linear, mipmap);
+    }
+
+    int pixel_size = 4;
+    if (format == vk::Format::eR5G6B5UnormPack16)
+        pixel_size = 2;
+
+    if (byte_stride == 0)
+    {
+        byte_stride = pixel_size * width;
+    }
+
+    auto map = allocator.mapMemory(buffer_allocation);
+    for (int y = 0; y < height; y++)
+    {
+        auto src = buffer + byte_stride * y;
+        auto dst = (uint8_t *)map + width * pixel_size * y;
+        memcpy(dst, src, width * pixel_size);
+    }
+    allocator.unmapMemory(buffer_allocation);
+    allocator.flushAllocation(buffer_allocation, 0, width * height * pixel_size);
+
+    auto srr = [](unsigned int i) { return vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, i, 1, 0, 1); };
+    auto srl = [](unsigned int i) { return vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, i, 0, 1); };
+
+    auto barrier = vk::ImageMemoryBarrier{}
+        .setImage(image)
+        .setOldLayout(vk::ImageLayout::eUndefined)
+        .setNewLayout(vk::ImageLayout::eTransferDstOptimal)
+        .setSrcAccessMask(vk::AccessFlagBits::eNone)
+        .setDstAccessMask(vk::AccessFlagBits::eTransferWrite)
+        .setSubresourceRange(srr(0));
+
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
+                        vk::PipelineStageFlagBits::eTransfer,
+                        {}, {}, {}, barrier);
+
+    auto buffer_image_copy = vk::BufferImageCopy{}
+        .setBufferOffset(0)
+        .setBufferRowLength(0)
+        .setBufferImageHeight(height)
+        .setImageExtent(vk::Extent3D(width, height, 1))
+        .setImageOffset(vk::Offset3D(0, 0, 0))
+        .setImageSubresource(srl(0));
+    cmd.copyBufferToImage(this->buffer, image, vk::ImageLayout::eTransferDstOptimal, buffer_image_copy);
+
+    auto mipmap_levels = mipmap ? mipmap_levels_for_size(image_width, image_height) : 1;
+
+    int base_width = image_width;
+    int base_height = image_height;
+    int base_level = 0;
+    for (; base_level + 1 < mipmap_levels; base_level++)
+    {
+        // Transition base layer to readable format.
+        barrier
+            .setImage(image)
+            .setOldLayout(vk::ImageLayout::eTransferDstOptimal)
+            .setNewLayout(vk::ImageLayout::eTransferSrcOptimal)
+            .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+            .setDstAccessMask(vk::AccessFlagBits::eTransferRead)
+            .setSubresourceRange(srr(base_level));
+        
+        cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                            vk::PipelineStageFlagBits::eTransfer,
+                            {}, {}, {}, barrier);
+
+        // Transition mipmap layer to writable
+        barrier
+            .setImage(image)
+            .setOldLayout(vk::ImageLayout::eUndefined)
+            .setNewLayout(vk::ImageLayout::eTransferDstOptimal)
+            .setSrcAccessMask(vk::AccessFlagBits::eTransferRead)
+            .setDstAccessMask(vk::AccessFlagBits::eTransferWrite)
+            .setSubresourceRange(srr(base_level + 1));
+
+        cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                            vk::PipelineStageFlagBits::eTransfer,
+                            {}, {}, {}, barrier);
+
+        // Blit base layer to mipmap layer
+        int mipmap_width = base_width >> 1;
+        int mipmap_height = base_height >> 1;
+        if (mipmap_width < 1)
+            mipmap_width = 1;
+        if (mipmap_height < 1)
+            mipmap_height = 1;
+
+        auto blit = vk::ImageBlit{}
+            .setSrcOffsets({ vk::Offset3D(0, 0, 0), vk::Offset3D(base_width, base_height, 1) })
+            .setDstOffsets({ vk::Offset3D(0, 0, 0), vk::Offset3D(mipmap_width, mipmap_height, 1)})
+            .setSrcSubresource(srl(base_level))
+            .setDstSubresource(srl(base_level + 1));
+
+        base_width = mipmap_width;
+        base_height = mipmap_height;
+
+        cmd.blitImage(image, vk::ImageLayout::eTransferSrcOptimal, image, vk::ImageLayout::eTransferDstOptimal, blit, vk::Filter::eLinear);
+
+        // Transition base layer to shader readable
+        barrier
+            .setOldLayout(vk::ImageLayout::eTransferSrcOptimal)
+            .setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+            .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+            .setDstAccessMask(vk::AccessFlagBits::eShaderRead)
+            .setSubresourceRange(srr(base_level));
+
+        cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                            vk::PipelineStageFlagBits::eFragmentShader,
+                            {}, {}, {}, barrier);
+    }
+
+    // Transition final layer to shader readable
+    barrier
+        .setOldLayout(vk::ImageLayout::eTransferDstOptimal)
+        .setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
+        .setSrcAccessMask(vk::AccessFlagBits::eTransferWrite)
+        .setDstAccessMask(vk::AccessFlagBits::eShaderRead)
+        .setSubresourceRange(srr(base_level));
+
+    cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+                        vk::PipelineStageFlagBits::eFragmentShader,
+                        {}, {}, {}, barrier);
+}
+
+void Texture::from_buffer(uint8_t *buffer, int width, int height, int byte_stride)
+{
+    vk::CommandBufferAllocateInfo cbai(command_pool, vk::CommandBufferLevel::ePrimary, 1);
+    auto command_buffer_vector = device.allocateCommandBuffersUnique(cbai);
+    auto &cmd = command_buffer_vector[0];
+    cmd->begin({ vk::CommandBufferUsageFlagBits::eOneTimeSubmit });
+    from_buffer(cmd.get(), buffer, width, height, byte_stride);
+    cmd->end();
+    vk::SubmitInfo si{};
+    si.setCommandBuffers(cmd.get());
+    queue.submit(si);
+    queue.waitIdle();
+}
+
+void Texture::create(int width, int height, vk::Format fmt, vk::SamplerAddressMode wrap_mode, bool linear, bool mipmap)
+{
+    assert(image_width + image_height + buffer_size == 0);
+
+    this->mipmap = mipmap;
+    this->wrap_mode = wrap_mode;
+    this->linear = linear;
+    int mipmap_levels = mipmap ? mipmap_levels_for_size(width, height) : 1;
+    format = fmt;
+
+    auto aci = vma::AllocationCreateInfo{}
+        .setUsage(vma::MemoryUsage::eAuto);
+
+    auto ici = vk::ImageCreateInfo{}
+        .setUsage(vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled)
+        .setImageType(vk::ImageType::e2D)
+        .setExtent(vk::Extent3D(width, height, 1))
+        .setMipLevels(mipmap_levels)
+        .setArrayLayers(1)
+        .setFormat(format)
+        .setInitialLayout(vk::ImageLayout::eUndefined)
+        .setSamples(vk::SampleCountFlagBits::e1)
+        .setSharingMode(vk::SharingMode::eExclusive);
+
+    std::tie(image, image_allocation) = allocator.createImage(ici, aci);
+
+    buffer_size = width * height * 4;
+    if (format == vk::Format::eR5G6B5UnormPack16)
+        buffer_size = width * height * 2;
+    auto bci = vk::BufferCreateInfo{}
+        .setSize(buffer_size)
+        .setUsage(vk::BufferUsageFlagBits::eTransferSrc);
+
+    aci.setRequiredFlags(vk::MemoryPropertyFlagBits::eHostVisible)
+        .setFlags(vma::AllocationCreateFlagBits::eHostAccessSequentialWrite);
+
+    std::tie(buffer, buffer_allocation) = allocator.createBuffer(bci, aci);
+
+    auto isrr = vk::ImageSubresourceRange{}
+        .setAspectMask(vk::ImageAspectFlagBits::eColor)
+        .setBaseArrayLayer(0)
+        .setBaseMipLevel(0)
+        .setLayerCount(1)
+        .setLevelCount(mipmap_levels);
+    auto ivci = vk::ImageViewCreateInfo{}
+        .setImage(image)
+        .setViewType(vk::ImageViewType::e2D)
+        .setFormat(format)
+        .setComponents(vk::ComponentMapping())
+        .setSubresourceRange(isrr);
+
+    image_view = device.createImageView(ivci);
+
+    image_width = width;
+    image_height = height;
+
+    auto sampler_create_info = vk::SamplerCreateInfo{}
+        .setMagFilter(vk::Filter::eNearest)
+        .setMinFilter(vk::Filter::eNearest)
+        .setAddressModeU(wrap_mode)
+        .setAddressModeV(wrap_mode)
+        .setAddressModeW(wrap_mode)
+        .setBorderColor(vk::BorderColor::eFloatOpaqueBlack);
+
+    if (linear)
+        sampler_create_info
+            .setMagFilter(vk::Filter::eLinear)
+            .setMinFilter(vk::Filter::eLinear);
+    
+    if (mipmap)
+        sampler_create_info
+            .setMinLod(0.0f)
+            .setMaxLod(10000.0f)
+            .setMipmapMode(vk::SamplerMipmapMode::eLinear);
+
+    sampler = device.createSampler(sampler_create_info);
+}
+
+void Texture::discard_staging_buffer()
+{
+    if (buffer_size != 0)
+    {
+        allocator.destroyBuffer(buffer, buffer_allocation);
+        buffer_size = 0;
+    }
+}
+
+} // namespace Vulkan

vulkan/vulkan_texture.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "vk_mem_alloc.hpp"
+#include "vulkan_context.hpp"
+
+namespace Vulkan
+{
+
+struct Texture
+{
+    Texture();
+    void init(vk::Device device, vk::CommandPool command, vk::Queue queue, vma::Allocator allocator);
+    void init(Vulkan::Context *context);
+    ~Texture();
+
+    void create(int width, int height, vk::Format fmt, vk::SamplerAddressMode wrap_mode, bool linear, bool mipmap);
+    void destroy();
+    void from_buffer(vk::CommandBuffer cmd, uint8_t *buffer, int width, int height, int byte_stride = 0);
+    void from_buffer(uint8_t *buffer, int width, int height, int byte_stride = 0);
+    void discard_staging_buffer();
+
+    vk::Sampler sampler;
+    vk::ImageView image_view;
+    vk::Image image;
+    vk::Format format;
+    vk::SamplerAddressMode wrap_mode;
+    vma::Allocation image_allocation;
+    int image_width;
+    int image_height;
+    bool mipmap;
+    bool linear;
+
+    vk::Buffer buffer;
+    vma::Allocation buffer_allocation;
+    size_t buffer_size;
+
+    vk::Device device;
+    vk::Queue queue;
+    vk::CommandPool command_pool;
+    vma::Allocator allocator;
+};
+
+} // namespace Vulkan