Home | History | Annotate | Download | only in vulkan
      1 // Copyright (c) 2015-2016 The Khronos Group Inc.
      2 //
      3 // Permission is hereby granted, free of charge, to any person obtaining a
      4 // copy of this software and/or associated documentation files (the
      5 // "Materials"), to deal in the Materials without restriction, including
      6 // without limitation the rights to use, copy, modify, merge, publish,
      7 // distribute, sublicense, and/or sell copies of the Materials, and to
      8 // permit persons to whom the Materials are furnished to do so, subject to
      9 // the following conditions:
     10 //
     11 // The above copyright notice and this permission notice shall be included
     12 // in all copies or substantial portions of the Materials.
     13 //
     14 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     17 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     18 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     19 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     20 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
     21 
     22 // This header is generated from the Khronos Vulkan XML API Registry.
     23 
     24 
     25 #ifndef VULKAN_HPP
     26 #define VULKAN_HPP
     27 
     28 #include <algorithm>
     29 #include <array>
     30 #include <cassert>
     31 #include <cstdint>
     32 #include <cstring>
     33 #include <initializer_list>
     34 #include <string>
     35 #include <system_error>
     36 #include <type_traits>
     37 #include <vulkan/vulkan.h>
     38 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     39 # include <memory>
     40 # include <vector>
     41 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
     42 
     43 static_assert( VK_HEADER_VERSION ==  31 , "Wrong VK_HEADER_VERSION!" );
     44 
     45 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
     46 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
     47 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
     48 #define VULKAN_HPP_TYPESAFE_CONVERSION 1
     49 #endif
     50 
     51 #if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
     52 # if defined(__clang__)
     53 #  if __has_feature(cxx_unrestricted_unions)
     54 #   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
     55 #  endif
     56 # elif defined(__GNUC__)
     57 #  define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
     58 #  if 40600 <= GCC_VERSION
     59 #   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
     60 #  endif
     61 # elif defined(_MSC_VER)
     62 #  if 1900 <= _MSC_VER
     63 #   define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
     64 #  endif
     65 # endif
     66 #endif
     67 
     68 namespace vk
     69 {
     70   template <typename BitType, typename MaskType = VkFlags>
     71   class Flags
     72   {
     73   public:
     74     Flags()
     75       : m_mask(0)
     76     {
     77     }
     78 
     79     Flags(BitType bit)
     80       : m_mask(static_cast<MaskType>(bit))
     81     {
     82     }
     83 
     84     Flags(Flags<BitType> const& rhs)
     85       : m_mask(rhs.m_mask)
     86     {
     87     }
     88 
     89     Flags<BitType> & operator=(Flags<BitType> const& rhs)
     90     {
     91       m_mask = rhs.m_mask;
     92       return *this;
     93     }
     94 
     95     Flags<BitType> & operator|=(Flags<BitType> const& rhs)
     96     {
     97       m_mask |= rhs.m_mask;
     98       return *this;
     99     }
    100 
    101     Flags<BitType> & operator&=(Flags<BitType> const& rhs)
    102     {
    103       m_mask &= rhs.m_mask;
    104       return *this;
    105     }
    106 
    107     Flags<BitType> & operator^=(Flags<BitType> const& rhs)
    108     {
    109       m_mask ^= rhs.m_mask;
    110       return *this;
    111     }
    112 
    113     Flags<BitType> operator|(Flags<BitType> const& rhs) const
    114     {
    115       Flags<BitType> result(*this);
    116       result |= rhs;
    117       return result;
    118     }
    119 
    120     Flags<BitType> operator&(Flags<BitType> const& rhs) const
    121     {
    122       Flags<BitType> result(*this);
    123       result &= rhs;
    124       return result;
    125     }
    126 
    127     Flags<BitType> operator^(Flags<BitType> const& rhs) const
    128     {
    129       Flags<BitType> result(*this);
    130       result ^= rhs;
    131       return result;
    132     }
    133 
    134     bool operator!() const
    135     {
    136       return !m_mask;
    137     }
    138 
    139     bool operator==(Flags<BitType> const& rhs) const
    140     {
    141       return m_mask == rhs.m_mask;
    142     }
    143 
    144     bool operator!=(Flags<BitType> const& rhs) const
    145     {
    146       return m_mask != rhs.m_mask;
    147     }
    148 
    149     explicit operator bool() const
    150     {
    151       return !!m_mask;
    152     }
    153 
    154     explicit operator MaskType() const
    155     {
    156         return m_mask;
    157     }
    158 
    159   private:
    160     MaskType  m_mask;
    161   };
    162 
    163   template <typename BitType>
    164   Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags)
    165   {
    166     return flags | bit;
    167   }
    168 
    169   template <typename BitType>
    170   Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags)
    171   {
    172     return flags & bit;
    173   }
    174 
    175   template <typename BitType>
    176   Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags)
    177   {
    178     return flags ^ bit;
    179   }
    180 
    181   template <typename RefType>
    182   class Optional
    183   {
    184   public:
    185     Optional(RefType & reference) { m_ptr = &reference; }
    186     Optional(std::nullptr_t) { m_ptr = nullptr; }
    187 
    188     operator RefType*() const { return m_ptr; }
    189     RefType const* operator->() const { return m_ptr; }
    190     explicit operator bool() const { return !!m_ptr; }
    191 
    192   private:
    193     RefType *m_ptr;
    194   };
    195 
    196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
    197   template <typename T>
    198   class ArrayProxy
    199   {
    200   public:
    201     ArrayProxy(std::nullptr_t)
    202       : m_count(0)
    203       , m_ptr(nullptr)
    204     {}
    205 
    206     ArrayProxy(T & ptr)
    207       : m_count(1)
    208       , m_ptr(&ptr)
    209     {}
    210 
    211     ArrayProxy(uint32_t count, T * ptr)
    212       : m_count(count)
    213       , m_ptr(ptr)
    214     {}
    215 
    216     template <size_t N>
    217     ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
    218       : m_count(N)
    219       , m_ptr(data.data())
    220     {}
    221 
    222     template <size_t N>
    223     ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
    224       : m_count(N)
    225       , m_ptr(data.data())
    226     {}
    227 
    228     template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
    229     ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
    230       : m_count(static_cast<uint32_t>(data.size()))
    231       , m_ptr(data.data())
    232     {}
    233 
    234     template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
    235     ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
    236       : m_count(static_cast<uint32_t>(data.size()))
    237       , m_ptr(data.data())
    238     {}
    239 
    240     ArrayProxy(std::initializer_list<T> const& data)
    241       : m_count(static_cast<uint32_t>(data.end() - data.begin()))
    242       , m_ptr(data.begin())
    243     {}
    244 
    245     const T * begin() const
    246     {
    247       return m_ptr;
    248     }
    249 
    250     const T * end() const
    251     {
    252       return m_ptr + m_count;
    253     }
    254 
    255     const T & front() const
    256     {
    257       assert(m_count && m_ptr);
    258       return *m_ptr;
    259     }
    260 
    261     const T & back() const
    262     {
    263       assert(m_count && m_ptr);
    264       return *(m_ptr + m_count - 1);
    265     }
    266 
    267     bool empty() const
    268     {
    269       return (m_count == 0);
    270     }
    271 
    272     uint32_t size() const
    273     {
    274       return m_count;
    275     }
    276 
    277     T * data() const
    278     {
    279       return m_ptr;
    280     }
    281 
    282   private:
    283     uint32_t  m_count;
    284     T *       m_ptr;
    285   };
    286 #endif
    287 
    288   enum class Result
    289   {
    290     eSuccess = VK_SUCCESS,
    291     eNotReady = VK_NOT_READY,
    292     eTimeout = VK_TIMEOUT,
    293     eEventSet = VK_EVENT_SET,
    294     eEventReset = VK_EVENT_RESET,
    295     eIncomplete = VK_INCOMPLETE,
    296     eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
    297     eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
    298     eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
    299     eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
    300     eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
    301     eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
    302     eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
    303     eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
    304     eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
    305     eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
    306     eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
    307     eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
    308     eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
    309     eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
    310     eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
    311     eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
    312     eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
    313     eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
    314     eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV
    315   };
    316 
    317   inline std::string to_string(Result value)
    318   {
    319     switch (value)
    320     {
    321     case Result::eSuccess: return "Success";
    322     case Result::eNotReady: return "NotReady";
    323     case Result::eTimeout: return "Timeout";
    324     case Result::eEventSet: return "EventSet";
    325     case Result::eEventReset: return "EventReset";
    326     case Result::eIncomplete: return "Incomplete";
    327     case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory";
    328     case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory";
    329     case Result::eErrorInitializationFailed: return "ErrorInitializationFailed";
    330     case Result::eErrorDeviceLost: return "ErrorDeviceLost";
    331     case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed";
    332     case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent";
    333     case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent";
    334     case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent";
    335     case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver";
    336     case Result::eErrorTooManyObjects: return "ErrorTooManyObjects";
    337     case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported";
    338     case Result::eErrorFragmentedPool: return "ErrorFragmentedPool";
    339     case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR";
    340     case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR";
    341     case Result::eSuboptimalKHR: return "SuboptimalKHR";
    342     case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR";
    343     case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
    344     case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
    345     case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
    346     default: return "invalid";
    347     }
    348   }
    349 
    350 #if defined(_MSC_VER) && (_MSC_VER == 1800)
    351 # define noexcept _NOEXCEPT
    352 #endif
    353 
    354   class ErrorCategoryImpl : public std::error_category
    355   {
    356     public:
    357     virtual const char* name() const noexcept override { return "vk::Result"; }
    358     virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
    359   };
    360 
    361 #if defined(_MSC_VER) && (_MSC_VER == 1800)
    362 # undef noexcept
    363 #endif
    364 
    365   inline const std::error_category& errorCategory()
    366   {
    367     static ErrorCategoryImpl instance;
    368     return instance;
    369   }
    370 
    371   inline std::error_code make_error_code(Result e)
    372   {
    373     return std::error_code(static_cast<int>(e), errorCategory());
    374   }
    375 
    376   inline std::error_condition make_error_condition(Result e)
    377   {
    378     return std::error_condition(static_cast<int>(e), errorCategory());
    379   }
    380 
    381 } // namespace vk
    382 
    383 namespace std
    384 {
    385   template <>
    386   struct is_error_code_enum<vk::Result> : public true_type
    387   {};
    388 }
    389 
    390 namespace vk
    391 {
    392   template <typename T>
    393   struct ResultValue
    394   {
    395     ResultValue( Result r, T & v )
    396       : result( r )
    397       , value( v )
    398     {}
    399 
    400     Result  result;
    401     T       value;
    402   };
    403 
    404   template <typename T>
    405   struct ResultValueType
    406   {
    407 #ifdef VULKAN_HPP_NO_EXCEPTIONS
    408     typedef ResultValue<T>  type;
    409 #else
    410     typedef T              type;
    411 #endif
    412   };
    413 
    414   template <>  struct ResultValueType<void>
    415   {
    416 #ifdef VULKAN_HPP_NO_EXCEPTIONS
    417     typedef Result type;
    418 #else
    419     typedef void   type;
    420 #endif
    421   };
    422 
    423   inline ResultValueType<void>::type createResultValue( Result result, char const * message )
    424   {
    425 #ifdef VULKAN_HPP_NO_EXCEPTIONS
    426     assert( result == Result::eSuccess );
    427     return result;
    428 #else
    429     if ( result != Result::eSuccess )
    430     {
    431       throw std::system_error( result, message );
    432     }
    433 #endif
    434   }
    435 
    436   template <typename T>
    437   inline typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
    438   {
    439 #ifdef VULKAN_HPP_NO_EXCEPTIONS
    440     assert( result == Result::eSuccess );
    441     return ResultValue<T>( result, data );
    442 #else
    443     if ( result != Result::eSuccess )
    444     {
    445       throw std::system_error( result, message );
    446     }
    447     return data;
    448 #endif
    449   }
    450 
    451   inline Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
    452   {
    453 #ifdef VULKAN_HPP_NO_EXCEPTIONS
    454     assert( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
    455 #else
    456     if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
    457     {
    458       throw std::system_error( result, message );
    459     }
    460 #endif
    461     return result;
    462   }
    463 
    464   template <typename T>
    465   inline ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
    466   {
    467 #ifdef VULKAN_HPP_NO_EXCEPTIONS
    468     assert( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
    469 #else
    470     if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
    471     {
    472       throw std::system_error( result, message );
    473     }
    474 #endif
    475     return ResultValue<T>( result, data );
    476   }
    477 
    478   using SampleMask = uint32_t;
    479 
    480   using Bool32 = uint32_t;
    481 
    482   using DeviceSize = uint64_t;
    483 
    484   enum class FramebufferCreateFlagBits
    485   {
    486   };
    487 
    488   using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
    489 
    490   inline FramebufferCreateFlags operator|( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
    491   {
    492     return FramebufferCreateFlags( bit0 ) | bit1;
    493   }
    494 
    495   enum class QueryPoolCreateFlagBits
    496   {
    497   };
    498 
    499   using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;
    500 
    501   inline QueryPoolCreateFlags operator|( QueryPoolCreateFlagBits bit0, QueryPoolCreateFlagBits bit1 )
    502   {
    503     return QueryPoolCreateFlags( bit0 ) | bit1;
    504   }
    505 
    506   enum class RenderPassCreateFlagBits
    507   {
    508   };
    509 
    510   using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;
    511 
    512   inline RenderPassCreateFlags operator|( RenderPassCreateFlagBits bit0, RenderPassCreateFlagBits bit1 )
    513   {
    514     return RenderPassCreateFlags( bit0 ) | bit1;
    515   }
    516 
    517   enum class SamplerCreateFlagBits
    518   {
    519   };
    520 
    521   using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
    522 
    523   inline SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
    524   {
    525     return SamplerCreateFlags( bit0 ) | bit1;
    526   }
    527 
    528   enum class PipelineLayoutCreateFlagBits
    529   {
    530   };
    531 
    532   using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;
    533 
    534   inline PipelineLayoutCreateFlags operator|( PipelineLayoutCreateFlagBits bit0, PipelineLayoutCreateFlagBits bit1 )
    535   {
    536     return PipelineLayoutCreateFlags( bit0 ) | bit1;
    537   }
    538 
    539   enum class PipelineCacheCreateFlagBits
    540   {
    541   };
    542 
    543   using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;
    544 
    545   inline PipelineCacheCreateFlags operator|( PipelineCacheCreateFlagBits bit0, PipelineCacheCreateFlagBits bit1 )
    546   {
    547     return PipelineCacheCreateFlags( bit0 ) | bit1;
    548   }
    549 
    550   enum class PipelineDepthStencilStateCreateFlagBits
    551   {
    552   };
    553 
    554   using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;
    555 
    556   inline PipelineDepthStencilStateCreateFlags operator|( PipelineDepthStencilStateCreateFlagBits bit0, PipelineDepthStencilStateCreateFlagBits bit1 )
    557   {
    558     return PipelineDepthStencilStateCreateFlags( bit0 ) | bit1;
    559   }
    560 
    561   enum class PipelineDynamicStateCreateFlagBits
    562   {
    563   };
    564 
    565   using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;
    566 
    567   inline PipelineDynamicStateCreateFlags operator|( PipelineDynamicStateCreateFlagBits bit0, PipelineDynamicStateCreateFlagBits bit1 )
    568   {
    569     return PipelineDynamicStateCreateFlags( bit0 ) | bit1;
    570   }
    571 
    572   enum class PipelineColorBlendStateCreateFlagBits
    573   {
    574   };
    575 
    576   using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;
    577 
    578   inline PipelineColorBlendStateCreateFlags operator|( PipelineColorBlendStateCreateFlagBits bit0, PipelineColorBlendStateCreateFlagBits bit1 )
    579   {
    580     return PipelineColorBlendStateCreateFlags( bit0 ) | bit1;
    581   }
    582 
    583   enum class PipelineMultisampleStateCreateFlagBits
    584   {
    585   };
    586 
    587   using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;
    588 
    589   inline PipelineMultisampleStateCreateFlags operator|( PipelineMultisampleStateCreateFlagBits bit0, PipelineMultisampleStateCreateFlagBits bit1 )
    590   {
    591     return PipelineMultisampleStateCreateFlags( bit0 ) | bit1;
    592   }
    593 
    594   enum class PipelineRasterizationStateCreateFlagBits
    595   {
    596   };
    597 
    598   using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;
    599 
    600   inline PipelineRasterizationStateCreateFlags operator|( PipelineRasterizationStateCreateFlagBits bit0, PipelineRasterizationStateCreateFlagBits bit1 )
    601   {
    602     return PipelineRasterizationStateCreateFlags( bit0 ) | bit1;
    603   }
    604 
    605   enum class PipelineViewportStateCreateFlagBits
    606   {
    607   };
    608 
    609   using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;
    610 
    611   inline PipelineViewportStateCreateFlags operator|( PipelineViewportStateCreateFlagBits bit0, PipelineViewportStateCreateFlagBits bit1 )
    612   {
    613     return PipelineViewportStateCreateFlags( bit0 ) | bit1;
    614   }
    615 
    616   enum class PipelineTessellationStateCreateFlagBits
    617   {
    618   };
    619 
    620   using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;
    621 
    622   inline PipelineTessellationStateCreateFlags operator|( PipelineTessellationStateCreateFlagBits bit0, PipelineTessellationStateCreateFlagBits bit1 )
    623   {
    624     return PipelineTessellationStateCreateFlags( bit0 ) | bit1;
    625   }
    626 
    627   enum class PipelineInputAssemblyStateCreateFlagBits
    628   {
    629   };
    630 
    631   using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;
    632 
    633   inline PipelineInputAssemblyStateCreateFlags operator|( PipelineInputAssemblyStateCreateFlagBits bit0, PipelineInputAssemblyStateCreateFlagBits bit1 )
    634   {
    635     return PipelineInputAssemblyStateCreateFlags( bit0 ) | bit1;
    636   }
    637 
    638   enum class PipelineVertexInputStateCreateFlagBits
    639   {
    640   };
    641 
    642   using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;
    643 
    644   inline PipelineVertexInputStateCreateFlags operator|( PipelineVertexInputStateCreateFlagBits bit0, PipelineVertexInputStateCreateFlagBits bit1 )
    645   {
    646     return PipelineVertexInputStateCreateFlags( bit0 ) | bit1;
    647   }
    648 
    649   enum class PipelineShaderStageCreateFlagBits
    650   {
    651   };
    652 
    653   using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
    654 
    655   inline PipelineShaderStageCreateFlags operator|( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
    656   {
    657     return PipelineShaderStageCreateFlags( bit0 ) | bit1;
    658   }
    659 
    660   enum class DescriptorSetLayoutCreateFlagBits
    661   {
    662   };
    663 
    664   using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
    665 
    666   inline DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
    667   {
    668     return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
    669   }
    670 
    671   enum class BufferViewCreateFlagBits
    672   {
    673   };
    674 
    675   using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
    676 
    677   inline BufferViewCreateFlags operator|( BufferViewCreateFlagBits bit0, BufferViewCreateFlagBits bit1 )
    678   {
    679     return BufferViewCreateFlags( bit0 ) | bit1;
    680   }
    681 
    682   enum class InstanceCreateFlagBits
    683   {
    684   };
    685 
    686   using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;
    687 
    688   inline InstanceCreateFlags operator|( InstanceCreateFlagBits bit0, InstanceCreateFlagBits bit1 )
    689   {
    690     return InstanceCreateFlags( bit0 ) | bit1;
    691   }
    692 
    693   enum class DeviceCreateFlagBits
    694   {
    695   };
    696 
    697   using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;
    698 
    699   inline DeviceCreateFlags operator|( DeviceCreateFlagBits bit0, DeviceCreateFlagBits bit1 )
    700   {
    701     return DeviceCreateFlags( bit0 ) | bit1;
    702   }
    703 
    704   enum class DeviceQueueCreateFlagBits
    705   {
    706   };
    707 
    708   using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
    709 
    710   inline DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
    711   {
    712     return DeviceQueueCreateFlags( bit0 ) | bit1;
    713   }
    714 
    715   enum class ImageViewCreateFlagBits
    716   {
    717   };
    718 
    719   using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
    720 
    721   inline ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
    722   {
    723     return ImageViewCreateFlags( bit0 ) | bit1;
    724   }
    725 
    726   enum class SemaphoreCreateFlagBits
    727   {
    728   };
    729 
    730   using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;
    731 
    732   inline SemaphoreCreateFlags operator|( SemaphoreCreateFlagBits bit0, SemaphoreCreateFlagBits bit1 )
    733   {
    734     return SemaphoreCreateFlags( bit0 ) | bit1;
    735   }
    736 
    737   enum class ShaderModuleCreateFlagBits
    738   {
    739   };
    740 
    741   using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;
    742 
    743   inline ShaderModuleCreateFlags operator|( ShaderModuleCreateFlagBits bit0, ShaderModuleCreateFlagBits bit1 )
    744   {
    745     return ShaderModuleCreateFlags( bit0 ) | bit1;
    746   }
    747 
    748   enum class EventCreateFlagBits
    749   {
    750   };
    751 
    752   using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;
    753 
    754   inline EventCreateFlags operator|( EventCreateFlagBits bit0, EventCreateFlagBits bit1 )
    755   {
    756     return EventCreateFlags( bit0 ) | bit1;
    757   }
    758 
    759   enum class MemoryMapFlagBits
    760   {
    761   };
    762 
    763   using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;
    764 
    765   inline MemoryMapFlags operator|( MemoryMapFlagBits bit0, MemoryMapFlagBits bit1 )
    766   {
    767     return MemoryMapFlags( bit0 ) | bit1;
    768   }
    769 
    770   enum class SubpassDescriptionFlagBits
    771   {
    772   };
    773 
    774   using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
    775 
    776   inline SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
    777   {
    778     return SubpassDescriptionFlags( bit0 ) | bit1;
    779   }
    780 
    781   enum class DescriptorPoolResetFlagBits
    782   {
    783   };
    784 
    785   using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;
    786 
    787   inline DescriptorPoolResetFlags operator|( DescriptorPoolResetFlagBits bit0, DescriptorPoolResetFlagBits bit1 )
    788   {
    789     return DescriptorPoolResetFlags( bit0 ) | bit1;
    790   }
    791 
    792   enum class SwapchainCreateFlagBitsKHR
    793   {
    794   };
    795 
    796   using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
    797 
    798   inline SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
    799   {
    800     return SwapchainCreateFlagsKHR( bit0 ) | bit1;
    801   }
    802 
    803   enum class DisplayModeCreateFlagBitsKHR
    804   {
    805   };
    806 
    807   using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;
    808 
    809   inline DisplayModeCreateFlagsKHR operator|( DisplayModeCreateFlagBitsKHR bit0, DisplayModeCreateFlagBitsKHR bit1 )
    810   {
    811     return DisplayModeCreateFlagsKHR( bit0 ) | bit1;
    812   }
    813 
    814   enum class DisplaySurfaceCreateFlagBitsKHR
    815   {
    816   };
    817 
    818   using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;
    819 
    820   inline DisplaySurfaceCreateFlagsKHR operator|( DisplaySurfaceCreateFlagBitsKHR bit0, DisplaySurfaceCreateFlagBitsKHR bit1 )
    821   {
    822     return DisplaySurfaceCreateFlagsKHR( bit0 ) | bit1;
    823   }
    824 
    825 #ifdef VK_USE_PLATFORM_ANDROID_KHR
    826   enum class AndroidSurfaceCreateFlagBitsKHR
    827   {
    828   };
    829 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
    830 
    831 #ifdef VK_USE_PLATFORM_ANDROID_KHR
    832   using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
    833 
    834   inline AndroidSurfaceCreateFlagsKHR operator|( AndroidSurfaceCreateFlagBitsKHR bit0, AndroidSurfaceCreateFlagBitsKHR bit1 )
    835   {
    836     return AndroidSurfaceCreateFlagsKHR( bit0 ) | bit1;
    837   }
    838 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
    839 
    840 #ifdef VK_USE_PLATFORM_MIR_KHR
    841   enum class MirSurfaceCreateFlagBitsKHR
    842   {
    843   };
    844 #endif /*VK_USE_PLATFORM_MIR_KHR*/
    845 
    846 #ifdef VK_USE_PLATFORM_MIR_KHR
    847   using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>;
    848 
    849   inline MirSurfaceCreateFlagsKHR operator|( MirSurfaceCreateFlagBitsKHR bit0, MirSurfaceCreateFlagBitsKHR bit1 )
    850   {
    851     return MirSurfaceCreateFlagsKHR( bit0 ) | bit1;
    852   }
    853 #endif /*VK_USE_PLATFORM_MIR_KHR*/
    854 
    855 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
    856   enum class WaylandSurfaceCreateFlagBitsKHR
    857   {
    858   };
    859 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
    860 
    861 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
    862   using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
    863 
    864   inline WaylandSurfaceCreateFlagsKHR operator|( WaylandSurfaceCreateFlagBitsKHR bit0, WaylandSurfaceCreateFlagBitsKHR bit1 )
    865   {
    866     return WaylandSurfaceCreateFlagsKHR( bit0 ) | bit1;
    867   }
    868 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
    869 
    870 #ifdef VK_USE_PLATFORM_WIN32_KHR
    871   enum class Win32SurfaceCreateFlagBitsKHR
    872   {
    873   };
    874 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
    875 
    876 #ifdef VK_USE_PLATFORM_WIN32_KHR
    877   using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
    878 
    879   inline Win32SurfaceCreateFlagsKHR operator|( Win32SurfaceCreateFlagBitsKHR bit0, Win32SurfaceCreateFlagBitsKHR bit1 )
    880   {
    881     return Win32SurfaceCreateFlagsKHR( bit0 ) | bit1;
    882   }
    883 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
    884 
    885 #ifdef VK_USE_PLATFORM_XLIB_KHR
    886   enum class XlibSurfaceCreateFlagBitsKHR
    887   {
    888   };
    889 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
    890 
    891 #ifdef VK_USE_PLATFORM_XLIB_KHR
    892   using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
    893 
    894   inline XlibSurfaceCreateFlagsKHR operator|( XlibSurfaceCreateFlagBitsKHR bit0, XlibSurfaceCreateFlagBitsKHR bit1 )
    895   {
    896     return XlibSurfaceCreateFlagsKHR( bit0 ) | bit1;
    897   }
    898 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
    899 
    900 #ifdef VK_USE_PLATFORM_XCB_KHR
    901   enum class XcbSurfaceCreateFlagBitsKHR
    902   {
    903   };
    904 #endif /*VK_USE_PLATFORM_XCB_KHR*/
    905 
    906 #ifdef VK_USE_PLATFORM_XCB_KHR
    907   using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
    908 
    909   inline XcbSurfaceCreateFlagsKHR operator|( XcbSurfaceCreateFlagBitsKHR bit0, XcbSurfaceCreateFlagBitsKHR bit1 )
    910   {
    911     return XcbSurfaceCreateFlagsKHR( bit0 ) | bit1;
    912   }
    913 #endif /*VK_USE_PLATFORM_XCB_KHR*/
    914 
    915   class DeviceMemory
    916   {
    917   public:
    918     DeviceMemory()
    919       : m_deviceMemory(VK_NULL_HANDLE)
    920     {}
    921 
    922 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
    923     DeviceMemory(VkDeviceMemory deviceMemory)
    924        : m_deviceMemory(deviceMemory)
    925     {}
    926 
    927     DeviceMemory& operator=(VkDeviceMemory deviceMemory)
    928     {
    929       m_deviceMemory = deviceMemory;
    930       return *this;
    931     }
    932 #endif
    933 
    934     bool operator==(DeviceMemory const &rhs) const
    935     {
    936       return m_deviceMemory == rhs.m_deviceMemory;
    937     }
    938 
    939     bool operator!=(DeviceMemory const &rhs) const
    940     {
    941       return m_deviceMemory != rhs.m_deviceMemory;
    942     }
    943 
    944     bool operator<(DeviceMemory const &rhs) const
    945     {
    946       return m_deviceMemory < rhs.m_deviceMemory;
    947     }
    948 
    949 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
    950     explicit
    951 #endif
    952     operator VkDeviceMemory() const
    953     {
    954       return m_deviceMemory;
    955     }
    956 
    957     explicit operator bool() const
    958     {
    959       return m_deviceMemory != VK_NULL_HANDLE;
    960     }
    961 
    962     bool operator!() const
    963     {
    964       return m_deviceMemory == VK_NULL_HANDLE;
    965     }
    966 
    967   private:
    968     VkDeviceMemory m_deviceMemory;
    969   };
    970   static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
    971 
    972   class CommandPool
    973   {
    974   public:
    975     CommandPool()
    976       : m_commandPool(VK_NULL_HANDLE)
    977     {}
    978 
    979 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
    980     CommandPool(VkCommandPool commandPool)
    981        : m_commandPool(commandPool)
    982     {}
    983 
    984     CommandPool& operator=(VkCommandPool commandPool)
    985     {
    986       m_commandPool = commandPool;
    987       return *this;
    988     }
    989 #endif
    990 
    991     bool operator==(CommandPool const &rhs) const
    992     {
    993       return m_commandPool == rhs.m_commandPool;
    994     }
    995 
    996     bool operator!=(CommandPool const &rhs) const
    997     {
    998       return m_commandPool != rhs.m_commandPool;
    999     }
   1000 
   1001     bool operator<(CommandPool const &rhs) const
   1002     {
   1003       return m_commandPool < rhs.m_commandPool;
   1004     }
   1005 
   1006 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1007     explicit
   1008 #endif
   1009     operator VkCommandPool() const
   1010     {
   1011       return m_commandPool;
   1012     }
   1013 
   1014     explicit operator bool() const
   1015     {
   1016       return m_commandPool != VK_NULL_HANDLE;
   1017     }
   1018 
   1019     bool operator!() const
   1020     {
   1021       return m_commandPool == VK_NULL_HANDLE;
   1022     }
   1023 
   1024   private:
   1025     VkCommandPool m_commandPool;
   1026   };
   1027   static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
   1028 
   1029   class Buffer
   1030   {
   1031   public:
   1032     Buffer()
   1033       : m_buffer(VK_NULL_HANDLE)
   1034     {}
   1035 
   1036 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1037     Buffer(VkBuffer buffer)
   1038        : m_buffer(buffer)
   1039     {}
   1040 
   1041     Buffer& operator=(VkBuffer buffer)
   1042     {
   1043       m_buffer = buffer;
   1044       return *this;
   1045     }
   1046 #endif
   1047 
   1048     bool operator==(Buffer const &rhs) const
   1049     {
   1050       return m_buffer == rhs.m_buffer;
   1051     }
   1052 
   1053     bool operator!=(Buffer const &rhs) const
   1054     {
   1055       return m_buffer != rhs.m_buffer;
   1056     }
   1057 
   1058     bool operator<(Buffer const &rhs) const
   1059     {
   1060       return m_buffer < rhs.m_buffer;
   1061     }
   1062 
   1063 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1064     explicit
   1065 #endif
   1066     operator VkBuffer() const
   1067     {
   1068       return m_buffer;
   1069     }
   1070 
   1071     explicit operator bool() const
   1072     {
   1073       return m_buffer != VK_NULL_HANDLE;
   1074     }
   1075 
   1076     bool operator!() const
   1077     {
   1078       return m_buffer == VK_NULL_HANDLE;
   1079     }
   1080 
   1081   private:
   1082     VkBuffer m_buffer;
   1083   };
   1084   static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
   1085 
   1086   class BufferView
   1087   {
   1088   public:
   1089     BufferView()
   1090       : m_bufferView(VK_NULL_HANDLE)
   1091     {}
   1092 
   1093 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1094     BufferView(VkBufferView bufferView)
   1095        : m_bufferView(bufferView)
   1096     {}
   1097 
   1098     BufferView& operator=(VkBufferView bufferView)
   1099     {
   1100       m_bufferView = bufferView;
   1101       return *this;
   1102     }
   1103 #endif
   1104 
   1105     bool operator==(BufferView const &rhs) const
   1106     {
   1107       return m_bufferView == rhs.m_bufferView;
   1108     }
   1109 
   1110     bool operator!=(BufferView const &rhs) const
   1111     {
   1112       return m_bufferView != rhs.m_bufferView;
   1113     }
   1114 
   1115     bool operator<(BufferView const &rhs) const
   1116     {
   1117       return m_bufferView < rhs.m_bufferView;
   1118     }
   1119 
   1120 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1121     explicit
   1122 #endif
   1123     operator VkBufferView() const
   1124     {
   1125       return m_bufferView;
   1126     }
   1127 
   1128     explicit operator bool() const
   1129     {
   1130       return m_bufferView != VK_NULL_HANDLE;
   1131     }
   1132 
   1133     bool operator!() const
   1134     {
   1135       return m_bufferView == VK_NULL_HANDLE;
   1136     }
   1137 
   1138   private:
   1139     VkBufferView m_bufferView;
   1140   };
   1141   static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
   1142 
   1143   class Image
   1144   {
   1145   public:
   1146     Image()
   1147       : m_image(VK_NULL_HANDLE)
   1148     {}
   1149 
   1150 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1151     Image(VkImage image)
   1152        : m_image(image)
   1153     {}
   1154 
   1155     Image& operator=(VkImage image)
   1156     {
   1157       m_image = image;
   1158       return *this;
   1159     }
   1160 #endif
   1161 
   1162     bool operator==(Image const &rhs) const
   1163     {
   1164       return m_image == rhs.m_image;
   1165     }
   1166 
   1167     bool operator!=(Image const &rhs) const
   1168     {
   1169       return m_image != rhs.m_image;
   1170     }
   1171 
   1172     bool operator<(Image const &rhs) const
   1173     {
   1174       return m_image < rhs.m_image;
   1175     }
   1176 
   1177 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1178     explicit
   1179 #endif
   1180     operator VkImage() const
   1181     {
   1182       return m_image;
   1183     }
   1184 
   1185     explicit operator bool() const
   1186     {
   1187       return m_image != VK_NULL_HANDLE;
   1188     }
   1189 
   1190     bool operator!() const
   1191     {
   1192       return m_image == VK_NULL_HANDLE;
   1193     }
   1194 
   1195   private:
   1196     VkImage m_image;
   1197   };
   1198   static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
   1199 
   1200   class ImageView
   1201   {
   1202   public:
   1203     ImageView()
   1204       : m_imageView(VK_NULL_HANDLE)
   1205     {}
   1206 
   1207 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1208     ImageView(VkImageView imageView)
   1209        : m_imageView(imageView)
   1210     {}
   1211 
   1212     ImageView& operator=(VkImageView imageView)
   1213     {
   1214       m_imageView = imageView;
   1215       return *this;
   1216     }
   1217 #endif
   1218 
   1219     bool operator==(ImageView const &rhs) const
   1220     {
   1221       return m_imageView == rhs.m_imageView;
   1222     }
   1223 
   1224     bool operator!=(ImageView const &rhs) const
   1225     {
   1226       return m_imageView != rhs.m_imageView;
   1227     }
   1228 
   1229     bool operator<(ImageView const &rhs) const
   1230     {
   1231       return m_imageView < rhs.m_imageView;
   1232     }
   1233 
   1234 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1235     explicit
   1236 #endif
   1237     operator VkImageView() const
   1238     {
   1239       return m_imageView;
   1240     }
   1241 
   1242     explicit operator bool() const
   1243     {
   1244       return m_imageView != VK_NULL_HANDLE;
   1245     }
   1246 
   1247     bool operator!() const
   1248     {
   1249       return m_imageView == VK_NULL_HANDLE;
   1250     }
   1251 
   1252   private:
   1253     VkImageView m_imageView;
   1254   };
   1255   static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
   1256 
   1257   class ShaderModule
   1258   {
   1259   public:
   1260     ShaderModule()
   1261       : m_shaderModule(VK_NULL_HANDLE)
   1262     {}
   1263 
   1264 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1265     ShaderModule(VkShaderModule shaderModule)
   1266        : m_shaderModule(shaderModule)
   1267     {}
   1268 
   1269     ShaderModule& operator=(VkShaderModule shaderModule)
   1270     {
   1271       m_shaderModule = shaderModule;
   1272       return *this;
   1273     }
   1274 #endif
   1275 
   1276     bool operator==(ShaderModule const &rhs) const
   1277     {
   1278       return m_shaderModule == rhs.m_shaderModule;
   1279     }
   1280 
   1281     bool operator!=(ShaderModule const &rhs) const
   1282     {
   1283       return m_shaderModule != rhs.m_shaderModule;
   1284     }
   1285 
   1286     bool operator<(ShaderModule const &rhs) const
   1287     {
   1288       return m_shaderModule < rhs.m_shaderModule;
   1289     }
   1290 
   1291 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1292     explicit
   1293 #endif
   1294     operator VkShaderModule() const
   1295     {
   1296       return m_shaderModule;
   1297     }
   1298 
   1299     explicit operator bool() const
   1300     {
   1301       return m_shaderModule != VK_NULL_HANDLE;
   1302     }
   1303 
   1304     bool operator!() const
   1305     {
   1306       return m_shaderModule == VK_NULL_HANDLE;
   1307     }
   1308 
   1309   private:
   1310     VkShaderModule m_shaderModule;
   1311   };
   1312   static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
   1313 
   1314   class Pipeline
   1315   {
   1316   public:
   1317     Pipeline()
   1318       : m_pipeline(VK_NULL_HANDLE)
   1319     {}
   1320 
   1321 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1322     Pipeline(VkPipeline pipeline)
   1323        : m_pipeline(pipeline)
   1324     {}
   1325 
   1326     Pipeline& operator=(VkPipeline pipeline)
   1327     {
   1328       m_pipeline = pipeline;
   1329       return *this;
   1330     }
   1331 #endif
   1332 
   1333     bool operator==(Pipeline const &rhs) const
   1334     {
   1335       return m_pipeline == rhs.m_pipeline;
   1336     }
   1337 
   1338     bool operator!=(Pipeline const &rhs) const
   1339     {
   1340       return m_pipeline != rhs.m_pipeline;
   1341     }
   1342 
   1343     bool operator<(Pipeline const &rhs) const
   1344     {
   1345       return m_pipeline < rhs.m_pipeline;
   1346     }
   1347 
   1348 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1349     explicit
   1350 #endif
   1351     operator VkPipeline() const
   1352     {
   1353       return m_pipeline;
   1354     }
   1355 
   1356     explicit operator bool() const
   1357     {
   1358       return m_pipeline != VK_NULL_HANDLE;
   1359     }
   1360 
   1361     bool operator!() const
   1362     {
   1363       return m_pipeline == VK_NULL_HANDLE;
   1364     }
   1365 
   1366   private:
   1367     VkPipeline m_pipeline;
   1368   };
   1369   static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
   1370 
   1371   class PipelineLayout
   1372   {
   1373   public:
   1374     PipelineLayout()
   1375       : m_pipelineLayout(VK_NULL_HANDLE)
   1376     {}
   1377 
   1378 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1379     PipelineLayout(VkPipelineLayout pipelineLayout)
   1380        : m_pipelineLayout(pipelineLayout)
   1381     {}
   1382 
   1383     PipelineLayout& operator=(VkPipelineLayout pipelineLayout)
   1384     {
   1385       m_pipelineLayout = pipelineLayout;
   1386       return *this;
   1387     }
   1388 #endif
   1389 
   1390     bool operator==(PipelineLayout const &rhs) const
   1391     {
   1392       return m_pipelineLayout == rhs.m_pipelineLayout;
   1393     }
   1394 
   1395     bool operator!=(PipelineLayout const &rhs) const
   1396     {
   1397       return m_pipelineLayout != rhs.m_pipelineLayout;
   1398     }
   1399 
   1400     bool operator<(PipelineLayout const &rhs) const
   1401     {
   1402       return m_pipelineLayout < rhs.m_pipelineLayout;
   1403     }
   1404 
   1405 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1406     explicit
   1407 #endif
   1408     operator VkPipelineLayout() const
   1409     {
   1410       return m_pipelineLayout;
   1411     }
   1412 
   1413     explicit operator bool() const
   1414     {
   1415       return m_pipelineLayout != VK_NULL_HANDLE;
   1416     }
   1417 
   1418     bool operator!() const
   1419     {
   1420       return m_pipelineLayout == VK_NULL_HANDLE;
   1421     }
   1422 
   1423   private:
   1424     VkPipelineLayout m_pipelineLayout;
   1425   };
   1426   static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
   1427 
   1428   class Sampler
   1429   {
   1430   public:
   1431     Sampler()
   1432       : m_sampler(VK_NULL_HANDLE)
   1433     {}
   1434 
   1435 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1436     Sampler(VkSampler sampler)
   1437        : m_sampler(sampler)
   1438     {}
   1439 
   1440     Sampler& operator=(VkSampler sampler)
   1441     {
   1442       m_sampler = sampler;
   1443       return *this;
   1444     }
   1445 #endif
   1446 
   1447     bool operator==(Sampler const &rhs) const
   1448     {
   1449       return m_sampler == rhs.m_sampler;
   1450     }
   1451 
   1452     bool operator!=(Sampler const &rhs) const
   1453     {
   1454       return m_sampler != rhs.m_sampler;
   1455     }
   1456 
   1457     bool operator<(Sampler const &rhs) const
   1458     {
   1459       return m_sampler < rhs.m_sampler;
   1460     }
   1461 
   1462 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1463     explicit
   1464 #endif
   1465     operator VkSampler() const
   1466     {
   1467       return m_sampler;
   1468     }
   1469 
   1470     explicit operator bool() const
   1471     {
   1472       return m_sampler != VK_NULL_HANDLE;
   1473     }
   1474 
   1475     bool operator!() const
   1476     {
   1477       return m_sampler == VK_NULL_HANDLE;
   1478     }
   1479 
   1480   private:
   1481     VkSampler m_sampler;
   1482   };
   1483   static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
   1484 
   1485   class DescriptorSet
   1486   {
   1487   public:
   1488     DescriptorSet()
   1489       : m_descriptorSet(VK_NULL_HANDLE)
   1490     {}
   1491 
   1492 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1493     DescriptorSet(VkDescriptorSet descriptorSet)
   1494        : m_descriptorSet(descriptorSet)
   1495     {}
   1496 
   1497     DescriptorSet& operator=(VkDescriptorSet descriptorSet)
   1498     {
   1499       m_descriptorSet = descriptorSet;
   1500       return *this;
   1501     }
   1502 #endif
   1503 
   1504     bool operator==(DescriptorSet const &rhs) const
   1505     {
   1506       return m_descriptorSet == rhs.m_descriptorSet;
   1507     }
   1508 
   1509     bool operator!=(DescriptorSet const &rhs) const
   1510     {
   1511       return m_descriptorSet != rhs.m_descriptorSet;
   1512     }
   1513 
   1514     bool operator<(DescriptorSet const &rhs) const
   1515     {
   1516       return m_descriptorSet < rhs.m_descriptorSet;
   1517     }
   1518 
   1519 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1520     explicit
   1521 #endif
   1522     operator VkDescriptorSet() const
   1523     {
   1524       return m_descriptorSet;
   1525     }
   1526 
   1527     explicit operator bool() const
   1528     {
   1529       return m_descriptorSet != VK_NULL_HANDLE;
   1530     }
   1531 
   1532     bool operator!() const
   1533     {
   1534       return m_descriptorSet == VK_NULL_HANDLE;
   1535     }
   1536 
   1537   private:
   1538     VkDescriptorSet m_descriptorSet;
   1539   };
   1540   static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
   1541 
   1542   class DescriptorSetLayout
   1543   {
   1544   public:
   1545     DescriptorSetLayout()
   1546       : m_descriptorSetLayout(VK_NULL_HANDLE)
   1547     {}
   1548 
   1549 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1550     DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)
   1551        : m_descriptorSetLayout(descriptorSetLayout)
   1552     {}
   1553 
   1554     DescriptorSetLayout& operator=(VkDescriptorSetLayout descriptorSetLayout)
   1555     {
   1556       m_descriptorSetLayout = descriptorSetLayout;
   1557       return *this;
   1558     }
   1559 #endif
   1560 
   1561     bool operator==(DescriptorSetLayout const &rhs) const
   1562     {
   1563       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
   1564     }
   1565 
   1566     bool operator!=(DescriptorSetLayout const &rhs) const
   1567     {
   1568       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
   1569     }
   1570 
   1571     bool operator<(DescriptorSetLayout const &rhs) const
   1572     {
   1573       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
   1574     }
   1575 
   1576 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1577     explicit
   1578 #endif
   1579     operator VkDescriptorSetLayout() const
   1580     {
   1581       return m_descriptorSetLayout;
   1582     }
   1583 
   1584     explicit operator bool() const
   1585     {
   1586       return m_descriptorSetLayout != VK_NULL_HANDLE;
   1587     }
   1588 
   1589     bool operator!() const
   1590     {
   1591       return m_descriptorSetLayout == VK_NULL_HANDLE;
   1592     }
   1593 
   1594   private:
   1595     VkDescriptorSetLayout m_descriptorSetLayout;
   1596   };
   1597   static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
   1598 
   1599   class DescriptorPool
   1600   {
   1601   public:
   1602     DescriptorPool()
   1603       : m_descriptorPool(VK_NULL_HANDLE)
   1604     {}
   1605 
   1606 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1607     DescriptorPool(VkDescriptorPool descriptorPool)
   1608        : m_descriptorPool(descriptorPool)
   1609     {}
   1610 
   1611     DescriptorPool& operator=(VkDescriptorPool descriptorPool)
   1612     {
   1613       m_descriptorPool = descriptorPool;
   1614       return *this;
   1615     }
   1616 #endif
   1617 
   1618     bool operator==(DescriptorPool const &rhs) const
   1619     {
   1620       return m_descriptorPool == rhs.m_descriptorPool;
   1621     }
   1622 
   1623     bool operator!=(DescriptorPool const &rhs) const
   1624     {
   1625       return m_descriptorPool != rhs.m_descriptorPool;
   1626     }
   1627 
   1628     bool operator<(DescriptorPool const &rhs) const
   1629     {
   1630       return m_descriptorPool < rhs.m_descriptorPool;
   1631     }
   1632 
   1633 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1634     explicit
   1635 #endif
   1636     operator VkDescriptorPool() const
   1637     {
   1638       return m_descriptorPool;
   1639     }
   1640 
   1641     explicit operator bool() const
   1642     {
   1643       return m_descriptorPool != VK_NULL_HANDLE;
   1644     }
   1645 
   1646     bool operator!() const
   1647     {
   1648       return m_descriptorPool == VK_NULL_HANDLE;
   1649     }
   1650 
   1651   private:
   1652     VkDescriptorPool m_descriptorPool;
   1653   };
   1654   static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
   1655 
   1656   class Fence
   1657   {
   1658   public:
   1659     Fence()
   1660       : m_fence(VK_NULL_HANDLE)
   1661     {}
   1662 
   1663 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1664     Fence(VkFence fence)
   1665        : m_fence(fence)
   1666     {}
   1667 
   1668     Fence& operator=(VkFence fence)
   1669     {
   1670       m_fence = fence;
   1671       return *this;
   1672     }
   1673 #endif
   1674 
   1675     bool operator==(Fence const &rhs) const
   1676     {
   1677       return m_fence == rhs.m_fence;
   1678     }
   1679 
   1680     bool operator!=(Fence const &rhs) const
   1681     {
   1682       return m_fence != rhs.m_fence;
   1683     }
   1684 
   1685     bool operator<(Fence const &rhs) const
   1686     {
   1687       return m_fence < rhs.m_fence;
   1688     }
   1689 
   1690 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1691     explicit
   1692 #endif
   1693     operator VkFence() const
   1694     {
   1695       return m_fence;
   1696     }
   1697 
   1698     explicit operator bool() const
   1699     {
   1700       return m_fence != VK_NULL_HANDLE;
   1701     }
   1702 
   1703     bool operator!() const
   1704     {
   1705       return m_fence == VK_NULL_HANDLE;
   1706     }
   1707 
   1708   private:
   1709     VkFence m_fence;
   1710   };
   1711   static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
   1712 
   1713   class Semaphore
   1714   {
   1715   public:
   1716     Semaphore()
   1717       : m_semaphore(VK_NULL_HANDLE)
   1718     {}
   1719 
   1720 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1721     Semaphore(VkSemaphore semaphore)
   1722        : m_semaphore(semaphore)
   1723     {}
   1724 
   1725     Semaphore& operator=(VkSemaphore semaphore)
   1726     {
   1727       m_semaphore = semaphore;
   1728       return *this;
   1729     }
   1730 #endif
   1731 
   1732     bool operator==(Semaphore const &rhs) const
   1733     {
   1734       return m_semaphore == rhs.m_semaphore;
   1735     }
   1736 
   1737     bool operator!=(Semaphore const &rhs) const
   1738     {
   1739       return m_semaphore != rhs.m_semaphore;
   1740     }
   1741 
   1742     bool operator<(Semaphore const &rhs) const
   1743     {
   1744       return m_semaphore < rhs.m_semaphore;
   1745     }
   1746 
   1747 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1748     explicit
   1749 #endif
   1750     operator VkSemaphore() const
   1751     {
   1752       return m_semaphore;
   1753     }
   1754 
   1755     explicit operator bool() const
   1756     {
   1757       return m_semaphore != VK_NULL_HANDLE;
   1758     }
   1759 
   1760     bool operator!() const
   1761     {
   1762       return m_semaphore == VK_NULL_HANDLE;
   1763     }
   1764 
   1765   private:
   1766     VkSemaphore m_semaphore;
   1767   };
   1768   static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
   1769 
   1770   class Event
   1771   {
   1772   public:
   1773     Event()
   1774       : m_event(VK_NULL_HANDLE)
   1775     {}
   1776 
   1777 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1778     Event(VkEvent event)
   1779        : m_event(event)
   1780     {}
   1781 
   1782     Event& operator=(VkEvent event)
   1783     {
   1784       m_event = event;
   1785       return *this;
   1786     }
   1787 #endif
   1788 
   1789     bool operator==(Event const &rhs) const
   1790     {
   1791       return m_event == rhs.m_event;
   1792     }
   1793 
   1794     bool operator!=(Event const &rhs) const
   1795     {
   1796       return m_event != rhs.m_event;
   1797     }
   1798 
   1799     bool operator<(Event const &rhs) const
   1800     {
   1801       return m_event < rhs.m_event;
   1802     }
   1803 
   1804 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1805     explicit
   1806 #endif
   1807     operator VkEvent() const
   1808     {
   1809       return m_event;
   1810     }
   1811 
   1812     explicit operator bool() const
   1813     {
   1814       return m_event != VK_NULL_HANDLE;
   1815     }
   1816 
   1817     bool operator!() const
   1818     {
   1819       return m_event == VK_NULL_HANDLE;
   1820     }
   1821 
   1822   private:
   1823     VkEvent m_event;
   1824   };
   1825   static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
   1826 
   1827   class QueryPool
   1828   {
   1829   public:
   1830     QueryPool()
   1831       : m_queryPool(VK_NULL_HANDLE)
   1832     {}
   1833 
   1834 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1835     QueryPool(VkQueryPool queryPool)
   1836        : m_queryPool(queryPool)
   1837     {}
   1838 
   1839     QueryPool& operator=(VkQueryPool queryPool)
   1840     {
   1841       m_queryPool = queryPool;
   1842       return *this;
   1843     }
   1844 #endif
   1845 
   1846     bool operator==(QueryPool const &rhs) const
   1847     {
   1848       return m_queryPool == rhs.m_queryPool;
   1849     }
   1850 
   1851     bool operator!=(QueryPool const &rhs) const
   1852     {
   1853       return m_queryPool != rhs.m_queryPool;
   1854     }
   1855 
   1856     bool operator<(QueryPool const &rhs) const
   1857     {
   1858       return m_queryPool < rhs.m_queryPool;
   1859     }
   1860 
   1861 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1862     explicit
   1863 #endif
   1864     operator VkQueryPool() const
   1865     {
   1866       return m_queryPool;
   1867     }
   1868 
   1869     explicit operator bool() const
   1870     {
   1871       return m_queryPool != VK_NULL_HANDLE;
   1872     }
   1873 
   1874     bool operator!() const
   1875     {
   1876       return m_queryPool == VK_NULL_HANDLE;
   1877     }
   1878 
   1879   private:
   1880     VkQueryPool m_queryPool;
   1881   };
   1882   static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
   1883 
   1884   class Framebuffer
   1885   {
   1886   public:
   1887     Framebuffer()
   1888       : m_framebuffer(VK_NULL_HANDLE)
   1889     {}
   1890 
   1891 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1892     Framebuffer(VkFramebuffer framebuffer)
   1893        : m_framebuffer(framebuffer)
   1894     {}
   1895 
   1896     Framebuffer& operator=(VkFramebuffer framebuffer)
   1897     {
   1898       m_framebuffer = framebuffer;
   1899       return *this;
   1900     }
   1901 #endif
   1902 
   1903     bool operator==(Framebuffer const &rhs) const
   1904     {
   1905       return m_framebuffer == rhs.m_framebuffer;
   1906     }
   1907 
   1908     bool operator!=(Framebuffer const &rhs) const
   1909     {
   1910       return m_framebuffer != rhs.m_framebuffer;
   1911     }
   1912 
   1913     bool operator<(Framebuffer const &rhs) const
   1914     {
   1915       return m_framebuffer < rhs.m_framebuffer;
   1916     }
   1917 
   1918 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1919     explicit
   1920 #endif
   1921     operator VkFramebuffer() const
   1922     {
   1923       return m_framebuffer;
   1924     }
   1925 
   1926     explicit operator bool() const
   1927     {
   1928       return m_framebuffer != VK_NULL_HANDLE;
   1929     }
   1930 
   1931     bool operator!() const
   1932     {
   1933       return m_framebuffer == VK_NULL_HANDLE;
   1934     }
   1935 
   1936   private:
   1937     VkFramebuffer m_framebuffer;
   1938   };
   1939   static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
   1940 
   1941   class RenderPass
   1942   {
   1943   public:
   1944     RenderPass()
   1945       : m_renderPass(VK_NULL_HANDLE)
   1946     {}
   1947 
   1948 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1949     RenderPass(VkRenderPass renderPass)
   1950        : m_renderPass(renderPass)
   1951     {}
   1952 
   1953     RenderPass& operator=(VkRenderPass renderPass)
   1954     {
   1955       m_renderPass = renderPass;
   1956       return *this;
   1957     }
   1958 #endif
   1959 
   1960     bool operator==(RenderPass const &rhs) const
   1961     {
   1962       return m_renderPass == rhs.m_renderPass;
   1963     }
   1964 
   1965     bool operator!=(RenderPass const &rhs) const
   1966     {
   1967       return m_renderPass != rhs.m_renderPass;
   1968     }
   1969 
   1970     bool operator<(RenderPass const &rhs) const
   1971     {
   1972       return m_renderPass < rhs.m_renderPass;
   1973     }
   1974 
   1975 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   1976     explicit
   1977 #endif
   1978     operator VkRenderPass() const
   1979     {
   1980       return m_renderPass;
   1981     }
   1982 
   1983     explicit operator bool() const
   1984     {
   1985       return m_renderPass != VK_NULL_HANDLE;
   1986     }
   1987 
   1988     bool operator!() const
   1989     {
   1990       return m_renderPass == VK_NULL_HANDLE;
   1991     }
   1992 
   1993   private:
   1994     VkRenderPass m_renderPass;
   1995   };
   1996   static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
   1997 
   1998   class PipelineCache
   1999   {
   2000   public:
   2001     PipelineCache()
   2002       : m_pipelineCache(VK_NULL_HANDLE)
   2003     {}
   2004 
   2005 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2006     PipelineCache(VkPipelineCache pipelineCache)
   2007        : m_pipelineCache(pipelineCache)
   2008     {}
   2009 
   2010     PipelineCache& operator=(VkPipelineCache pipelineCache)
   2011     {
   2012       m_pipelineCache = pipelineCache;
   2013       return *this;
   2014     }
   2015 #endif
   2016 
   2017     bool operator==(PipelineCache const &rhs) const
   2018     {
   2019       return m_pipelineCache == rhs.m_pipelineCache;
   2020     }
   2021 
   2022     bool operator!=(PipelineCache const &rhs) const
   2023     {
   2024       return m_pipelineCache != rhs.m_pipelineCache;
   2025     }
   2026 
   2027     bool operator<(PipelineCache const &rhs) const
   2028     {
   2029       return m_pipelineCache < rhs.m_pipelineCache;
   2030     }
   2031 
   2032 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2033     explicit
   2034 #endif
   2035     operator VkPipelineCache() const
   2036     {
   2037       return m_pipelineCache;
   2038     }
   2039 
   2040     explicit operator bool() const
   2041     {
   2042       return m_pipelineCache != VK_NULL_HANDLE;
   2043     }
   2044 
   2045     bool operator!() const
   2046     {
   2047       return m_pipelineCache == VK_NULL_HANDLE;
   2048     }
   2049 
   2050   private:
   2051     VkPipelineCache m_pipelineCache;
   2052   };
   2053   static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
   2054 
   2055   class DisplayKHR
   2056   {
   2057   public:
   2058     DisplayKHR()
   2059       : m_displayKHR(VK_NULL_HANDLE)
   2060     {}
   2061 
   2062 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2063     DisplayKHR(VkDisplayKHR displayKHR)
   2064        : m_displayKHR(displayKHR)
   2065     {}
   2066 
   2067     DisplayKHR& operator=(VkDisplayKHR displayKHR)
   2068     {
   2069       m_displayKHR = displayKHR;
   2070       return *this;
   2071     }
   2072 #endif
   2073 
   2074     bool operator==(DisplayKHR const &rhs) const
   2075     {
   2076       return m_displayKHR == rhs.m_displayKHR;
   2077     }
   2078 
   2079     bool operator!=(DisplayKHR const &rhs) const
   2080     {
   2081       return m_displayKHR != rhs.m_displayKHR;
   2082     }
   2083 
   2084     bool operator<(DisplayKHR const &rhs) const
   2085     {
   2086       return m_displayKHR < rhs.m_displayKHR;
   2087     }
   2088 
   2089 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2090     explicit
   2091 #endif
   2092     operator VkDisplayKHR() const
   2093     {
   2094       return m_displayKHR;
   2095     }
   2096 
   2097     explicit operator bool() const
   2098     {
   2099       return m_displayKHR != VK_NULL_HANDLE;
   2100     }
   2101 
   2102     bool operator!() const
   2103     {
   2104       return m_displayKHR == VK_NULL_HANDLE;
   2105     }
   2106 
   2107   private:
   2108     VkDisplayKHR m_displayKHR;
   2109   };
   2110   static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
   2111 
   2112   class DisplayModeKHR
   2113   {
   2114   public:
   2115     DisplayModeKHR()
   2116       : m_displayModeKHR(VK_NULL_HANDLE)
   2117     {}
   2118 
   2119 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2120     DisplayModeKHR(VkDisplayModeKHR displayModeKHR)
   2121        : m_displayModeKHR(displayModeKHR)
   2122     {}
   2123 
   2124     DisplayModeKHR& operator=(VkDisplayModeKHR displayModeKHR)
   2125     {
   2126       m_displayModeKHR = displayModeKHR;
   2127       return *this;
   2128     }
   2129 #endif
   2130 
   2131     bool operator==(DisplayModeKHR const &rhs) const
   2132     {
   2133       return m_displayModeKHR == rhs.m_displayModeKHR;
   2134     }
   2135 
   2136     bool operator!=(DisplayModeKHR const &rhs) const
   2137     {
   2138       return m_displayModeKHR != rhs.m_displayModeKHR;
   2139     }
   2140 
   2141     bool operator<(DisplayModeKHR const &rhs) const
   2142     {
   2143       return m_displayModeKHR < rhs.m_displayModeKHR;
   2144     }
   2145 
   2146 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2147     explicit
   2148 #endif
   2149     operator VkDisplayModeKHR() const
   2150     {
   2151       return m_displayModeKHR;
   2152     }
   2153 
   2154     explicit operator bool() const
   2155     {
   2156       return m_displayModeKHR != VK_NULL_HANDLE;
   2157     }
   2158 
   2159     bool operator!() const
   2160     {
   2161       return m_displayModeKHR == VK_NULL_HANDLE;
   2162     }
   2163 
   2164   private:
   2165     VkDisplayModeKHR m_displayModeKHR;
   2166   };
   2167   static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
   2168 
   2169   class SurfaceKHR
   2170   {
   2171   public:
   2172     SurfaceKHR()
   2173       : m_surfaceKHR(VK_NULL_HANDLE)
   2174     {}
   2175 
   2176 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2177     SurfaceKHR(VkSurfaceKHR surfaceKHR)
   2178        : m_surfaceKHR(surfaceKHR)
   2179     {}
   2180 
   2181     SurfaceKHR& operator=(VkSurfaceKHR surfaceKHR)
   2182     {
   2183       m_surfaceKHR = surfaceKHR;
   2184       return *this;
   2185     }
   2186 #endif
   2187 
   2188     bool operator==(SurfaceKHR const &rhs) const
   2189     {
   2190       return m_surfaceKHR == rhs.m_surfaceKHR;
   2191     }
   2192 
   2193     bool operator!=(SurfaceKHR const &rhs) const
   2194     {
   2195       return m_surfaceKHR != rhs.m_surfaceKHR;
   2196     }
   2197 
   2198     bool operator<(SurfaceKHR const &rhs) const
   2199     {
   2200       return m_surfaceKHR < rhs.m_surfaceKHR;
   2201     }
   2202 
   2203 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2204     explicit
   2205 #endif
   2206     operator VkSurfaceKHR() const
   2207     {
   2208       return m_surfaceKHR;
   2209     }
   2210 
   2211     explicit operator bool() const
   2212     {
   2213       return m_surfaceKHR != VK_NULL_HANDLE;
   2214     }
   2215 
   2216     bool operator!() const
   2217     {
   2218       return m_surfaceKHR == VK_NULL_HANDLE;
   2219     }
   2220 
   2221   private:
   2222     VkSurfaceKHR m_surfaceKHR;
   2223   };
   2224   static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
   2225 
   2226   class SwapchainKHR
   2227   {
   2228   public:
   2229     SwapchainKHR()
   2230       : m_swapchainKHR(VK_NULL_HANDLE)
   2231     {}
   2232 
   2233 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2234     SwapchainKHR(VkSwapchainKHR swapchainKHR)
   2235        : m_swapchainKHR(swapchainKHR)
   2236     {}
   2237 
   2238     SwapchainKHR& operator=(VkSwapchainKHR swapchainKHR)
   2239     {
   2240       m_swapchainKHR = swapchainKHR;
   2241       return *this;
   2242     }
   2243 #endif
   2244 
   2245     bool operator==(SwapchainKHR const &rhs) const
   2246     {
   2247       return m_swapchainKHR == rhs.m_swapchainKHR;
   2248     }
   2249 
   2250     bool operator!=(SwapchainKHR const &rhs) const
   2251     {
   2252       return m_swapchainKHR != rhs.m_swapchainKHR;
   2253     }
   2254 
   2255     bool operator<(SwapchainKHR const &rhs) const
   2256     {
   2257       return m_swapchainKHR < rhs.m_swapchainKHR;
   2258     }
   2259 
   2260 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2261     explicit
   2262 #endif
   2263     operator VkSwapchainKHR() const
   2264     {
   2265       return m_swapchainKHR;
   2266     }
   2267 
   2268     explicit operator bool() const
   2269     {
   2270       return m_swapchainKHR != VK_NULL_HANDLE;
   2271     }
   2272 
   2273     bool operator!() const
   2274     {
   2275       return m_swapchainKHR == VK_NULL_HANDLE;
   2276     }
   2277 
   2278   private:
   2279     VkSwapchainKHR m_swapchainKHR;
   2280   };
   2281   static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
   2282 
   2283   class DebugReportCallbackEXT
   2284   {
   2285   public:
   2286     DebugReportCallbackEXT()
   2287       : m_debugReportCallbackEXT(VK_NULL_HANDLE)
   2288     {}
   2289 
   2290 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2291     DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)
   2292        : m_debugReportCallbackEXT(debugReportCallbackEXT)
   2293     {}
   2294 
   2295     DebugReportCallbackEXT& operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
   2296     {
   2297       m_debugReportCallbackEXT = debugReportCallbackEXT;
   2298       return *this;
   2299     }
   2300 #endif
   2301 
   2302     bool operator==(DebugReportCallbackEXT const &rhs) const
   2303     {
   2304       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
   2305     }
   2306 
   2307     bool operator!=(DebugReportCallbackEXT const &rhs) const
   2308     {
   2309       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
   2310     }
   2311 
   2312     bool operator<(DebugReportCallbackEXT const &rhs) const
   2313     {
   2314       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
   2315     }
   2316 
   2317 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   2318     explicit
   2319 #endif
   2320     operator VkDebugReportCallbackEXT() const
   2321     {
   2322       return m_debugReportCallbackEXT;
   2323     }
   2324 
   2325     explicit operator bool() const
   2326     {
   2327       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
   2328     }
   2329 
   2330     bool operator!() const
   2331     {
   2332       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
   2333     }
   2334 
   2335   private:
   2336     VkDebugReportCallbackEXT m_debugReportCallbackEXT;
   2337   };
   2338   static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
   2339 
   2340   struct Offset2D
   2341   {
   2342     Offset2D( int32_t x_ = 0, int32_t y_ = 0 )
   2343       : x( x_ )
   2344       , y( y_ )
   2345     {
   2346     }
   2347 
   2348     Offset2D( VkOffset2D const & rhs )
   2349     {
   2350       memcpy( this, &rhs, sizeof(Offset2D) );
   2351     }
   2352 
   2353     Offset2D& operator=( VkOffset2D const & rhs )
   2354     {
   2355       memcpy( this, &rhs, sizeof(Offset2D) );
   2356       return *this;
   2357     }
   2358 
   2359     Offset2D& setX( int32_t x_ )
   2360     {
   2361       x = x_;
   2362       return *this;
   2363     }
   2364 
   2365     Offset2D& setY( int32_t y_ )
   2366     {
   2367       y = y_;
   2368       return *this;
   2369     }
   2370 
   2371     operator const VkOffset2D&() const
   2372     {
   2373       return *reinterpret_cast<const VkOffset2D*>(this);
   2374     }
   2375 
   2376     bool operator==( Offset2D const& rhs ) const
   2377     {
   2378       return ( x == rhs.x )
   2379           && ( y == rhs.y );
   2380     }
   2381 
   2382     bool operator!=( Offset2D const& rhs ) const
   2383     {
   2384       return !operator==( rhs );
   2385     }
   2386 
   2387     int32_t x;
   2388     int32_t y;
   2389   };
   2390   static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
   2391 
   2392   struct Offset3D
   2393   {
   2394     Offset3D( int32_t x_ = 0, int32_t y_ = 0, int32_t z_ = 0 )
   2395       : x( x_ )
   2396       , y( y_ )
   2397       , z( z_ )
   2398     {
   2399     }
   2400 
   2401     Offset3D( VkOffset3D const & rhs )
   2402     {
   2403       memcpy( this, &rhs, sizeof(Offset3D) );
   2404     }
   2405 
   2406     Offset3D& operator=( VkOffset3D const & rhs )
   2407     {
   2408       memcpy( this, &rhs, sizeof(Offset3D) );
   2409       return *this;
   2410     }
   2411 
   2412     Offset3D& setX( int32_t x_ )
   2413     {
   2414       x = x_;
   2415       return *this;
   2416     }
   2417 
   2418     Offset3D& setY( int32_t y_ )
   2419     {
   2420       y = y_;
   2421       return *this;
   2422     }
   2423 
   2424     Offset3D& setZ( int32_t z_ )
   2425     {
   2426       z = z_;
   2427       return *this;
   2428     }
   2429 
   2430     operator const VkOffset3D&() const
   2431     {
   2432       return *reinterpret_cast<const VkOffset3D*>(this);
   2433     }
   2434 
   2435     bool operator==( Offset3D const& rhs ) const
   2436     {
   2437       return ( x == rhs.x )
   2438           && ( y == rhs.y )
   2439           && ( z == rhs.z );
   2440     }
   2441 
   2442     bool operator!=( Offset3D const& rhs ) const
   2443     {
   2444       return !operator==( rhs );
   2445     }
   2446 
   2447     int32_t x;
   2448     int32_t y;
   2449     int32_t z;
   2450   };
   2451   static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
   2452 
   2453   struct Extent2D
   2454   {
   2455     Extent2D( uint32_t width_ = 0, uint32_t height_ = 0 )
   2456       : width( width_ )
   2457       , height( height_ )
   2458     {
   2459     }
   2460 
   2461     Extent2D( VkExtent2D const & rhs )
   2462     {
   2463       memcpy( this, &rhs, sizeof(Extent2D) );
   2464     }
   2465 
   2466     Extent2D& operator=( VkExtent2D const & rhs )
   2467     {
   2468       memcpy( this, &rhs, sizeof(Extent2D) );
   2469       return *this;
   2470     }
   2471 
   2472     Extent2D& setWidth( uint32_t width_ )
   2473     {
   2474       width = width_;
   2475       return *this;
   2476     }
   2477 
   2478     Extent2D& setHeight( uint32_t height_ )
   2479     {
   2480       height = height_;
   2481       return *this;
   2482     }
   2483 
   2484     operator const VkExtent2D&() const
   2485     {
   2486       return *reinterpret_cast<const VkExtent2D*>(this);
   2487     }
   2488 
   2489     bool operator==( Extent2D const& rhs ) const
   2490     {
   2491       return ( width == rhs.width )
   2492           && ( height == rhs.height );
   2493     }
   2494 
   2495     bool operator!=( Extent2D const& rhs ) const
   2496     {
   2497       return !operator==( rhs );
   2498     }
   2499 
   2500     uint32_t width;
   2501     uint32_t height;
   2502   };
   2503   static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
   2504 
   2505   struct Extent3D
   2506   {
   2507     Extent3D( uint32_t width_ = 0, uint32_t height_ = 0, uint32_t depth_ = 0 )
   2508       : width( width_ )
   2509       , height( height_ )
   2510       , depth( depth_ )
   2511     {
   2512     }
   2513 
   2514     Extent3D( VkExtent3D const & rhs )
   2515     {
   2516       memcpy( this, &rhs, sizeof(Extent3D) );
   2517     }
   2518 
   2519     Extent3D& operator=( VkExtent3D const & rhs )
   2520     {
   2521       memcpy( this, &rhs, sizeof(Extent3D) );
   2522       return *this;
   2523     }
   2524 
   2525     Extent3D& setWidth( uint32_t width_ )
   2526     {
   2527       width = width_;
   2528       return *this;
   2529     }
   2530 
   2531     Extent3D& setHeight( uint32_t height_ )
   2532     {
   2533       height = height_;
   2534       return *this;
   2535     }
   2536 
   2537     Extent3D& setDepth( uint32_t depth_ )
   2538     {
   2539       depth = depth_;
   2540       return *this;
   2541     }
   2542 
   2543     operator const VkExtent3D&() const
   2544     {
   2545       return *reinterpret_cast<const VkExtent3D*>(this);
   2546     }
   2547 
   2548     bool operator==( Extent3D const& rhs ) const
   2549     {
   2550       return ( width == rhs.width )
   2551           && ( height == rhs.height )
   2552           && ( depth == rhs.depth );
   2553     }
   2554 
   2555     bool operator!=( Extent3D const& rhs ) const
   2556     {
   2557       return !operator==( rhs );
   2558     }
   2559 
   2560     uint32_t width;
   2561     uint32_t height;
   2562     uint32_t depth;
   2563   };
   2564   static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
   2565 
   2566   struct Viewport
   2567   {
   2568     Viewport( float x_ = 0, float y_ = 0, float width_ = 0, float height_ = 0, float minDepth_ = 0, float maxDepth_ = 0 )
   2569       : x( x_ )
   2570       , y( y_ )
   2571       , width( width_ )
   2572       , height( height_ )
   2573       , minDepth( minDepth_ )
   2574       , maxDepth( maxDepth_ )
   2575     {
   2576     }
   2577 
   2578     Viewport( VkViewport const & rhs )
   2579     {
   2580       memcpy( this, &rhs, sizeof(Viewport) );
   2581     }
   2582 
   2583     Viewport& operator=( VkViewport const & rhs )
   2584     {
   2585       memcpy( this, &rhs, sizeof(Viewport) );
   2586       return *this;
   2587     }
   2588 
   2589     Viewport& setX( float x_ )
   2590     {
   2591       x = x_;
   2592       return *this;
   2593     }
   2594 
   2595     Viewport& setY( float y_ )
   2596     {
   2597       y = y_;
   2598       return *this;
   2599     }
   2600 
   2601     Viewport& setWidth( float width_ )
   2602     {
   2603       width = width_;
   2604       return *this;
   2605     }
   2606 
   2607     Viewport& setHeight( float height_ )
   2608     {
   2609       height = height_;
   2610       return *this;
   2611     }
   2612 
   2613     Viewport& setMinDepth( float minDepth_ )
   2614     {
   2615       minDepth = minDepth_;
   2616       return *this;
   2617     }
   2618 
   2619     Viewport& setMaxDepth( float maxDepth_ )
   2620     {
   2621       maxDepth = maxDepth_;
   2622       return *this;
   2623     }
   2624 
   2625     operator const VkViewport&() const
   2626     {
   2627       return *reinterpret_cast<const VkViewport*>(this);
   2628     }
   2629 
   2630     bool operator==( Viewport const& rhs ) const
   2631     {
   2632       return ( x == rhs.x )
   2633           && ( y == rhs.y )
   2634           && ( width == rhs.width )
   2635           && ( height == rhs.height )
   2636           && ( minDepth == rhs.minDepth )
   2637           && ( maxDepth == rhs.maxDepth );
   2638     }
   2639 
   2640     bool operator!=( Viewport const& rhs ) const
   2641     {
   2642       return !operator==( rhs );
   2643     }
   2644 
   2645     float x;
   2646     float y;
   2647     float width;
   2648     float height;
   2649     float minDepth;
   2650     float maxDepth;
   2651   };
   2652   static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
   2653 
   2654   struct Rect2D
   2655   {
   2656     Rect2D( Offset2D offset_ = Offset2D(), Extent2D extent_ = Extent2D() )
   2657       : offset( offset_ )
   2658       , extent( extent_ )
   2659     {
   2660     }
   2661 
   2662     Rect2D( VkRect2D const & rhs )
   2663     {
   2664       memcpy( this, &rhs, sizeof(Rect2D) );
   2665     }
   2666 
   2667     Rect2D& operator=( VkRect2D const & rhs )
   2668     {
   2669       memcpy( this, &rhs, sizeof(Rect2D) );
   2670       return *this;
   2671     }
   2672 
   2673     Rect2D& setOffset( Offset2D offset_ )
   2674     {
   2675       offset = offset_;
   2676       return *this;
   2677     }
   2678 
   2679     Rect2D& setExtent( Extent2D extent_ )
   2680     {
   2681       extent = extent_;
   2682       return *this;
   2683     }
   2684 
   2685     operator const VkRect2D&() const
   2686     {
   2687       return *reinterpret_cast<const VkRect2D*>(this);
   2688     }
   2689 
   2690     bool operator==( Rect2D const& rhs ) const
   2691     {
   2692       return ( offset == rhs.offset )
   2693           && ( extent == rhs.extent );
   2694     }
   2695 
   2696     bool operator!=( Rect2D const& rhs ) const
   2697     {
   2698       return !operator==( rhs );
   2699     }
   2700 
   2701     Offset2D offset;
   2702     Extent2D extent;
   2703   };
   2704   static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
   2705 
   2706   struct ClearRect
   2707   {
   2708     ClearRect( Rect2D rect_ = Rect2D(), uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
   2709       : rect( rect_ )
   2710       , baseArrayLayer( baseArrayLayer_ )
   2711       , layerCount( layerCount_ )
   2712     {
   2713     }
   2714 
   2715     ClearRect( VkClearRect const & rhs )
   2716     {
   2717       memcpy( this, &rhs, sizeof(ClearRect) );
   2718     }
   2719 
   2720     ClearRect& operator=( VkClearRect const & rhs )
   2721     {
   2722       memcpy( this, &rhs, sizeof(ClearRect) );
   2723       return *this;
   2724     }
   2725 
   2726     ClearRect& setRect( Rect2D rect_ )
   2727     {
   2728       rect = rect_;
   2729       return *this;
   2730     }
   2731 
   2732     ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ )
   2733     {
   2734       baseArrayLayer = baseArrayLayer_;
   2735       return *this;
   2736     }
   2737 
   2738     ClearRect& setLayerCount( uint32_t layerCount_ )
   2739     {
   2740       layerCount = layerCount_;
   2741       return *this;
   2742     }
   2743 
   2744     operator const VkClearRect&() const
   2745     {
   2746       return *reinterpret_cast<const VkClearRect*>(this);
   2747     }
   2748 
   2749     bool operator==( ClearRect const& rhs ) const
   2750     {
   2751       return ( rect == rhs.rect )
   2752           && ( baseArrayLayer == rhs.baseArrayLayer )
   2753           && ( layerCount == rhs.layerCount );
   2754     }
   2755 
   2756     bool operator!=( ClearRect const& rhs ) const
   2757     {
   2758       return !operator==( rhs );
   2759     }
   2760 
   2761     Rect2D rect;
   2762     uint32_t baseArrayLayer;
   2763     uint32_t layerCount;
   2764   };
   2765   static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
   2766 
   2767   struct ExtensionProperties
   2768   {
   2769     operator const VkExtensionProperties&() const
   2770     {
   2771       return *reinterpret_cast<const VkExtensionProperties*>(this);
   2772     }
   2773 
   2774     bool operator==( ExtensionProperties const& rhs ) const
   2775     {
   2776       return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
   2777           && ( specVersion == rhs.specVersion );
   2778     }
   2779 
   2780     bool operator!=( ExtensionProperties const& rhs ) const
   2781     {
   2782       return !operator==( rhs );
   2783     }
   2784 
   2785     char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
   2786     uint32_t specVersion;
   2787   };
   2788   static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
   2789 
   2790   struct LayerProperties
   2791   {
   2792     operator const VkLayerProperties&() const
   2793     {
   2794       return *reinterpret_cast<const VkLayerProperties*>(this);
   2795     }
   2796 
   2797     bool operator==( LayerProperties const& rhs ) const
   2798     {
   2799       return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
   2800           && ( specVersion == rhs.specVersion )
   2801           && ( implementationVersion == rhs.implementationVersion )
   2802           && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
   2803     }
   2804 
   2805     bool operator!=( LayerProperties const& rhs ) const
   2806     {
   2807       return !operator==( rhs );
   2808     }
   2809 
   2810     char layerName[VK_MAX_EXTENSION_NAME_SIZE];
   2811     uint32_t specVersion;
   2812     uint32_t implementationVersion;
   2813     char description[VK_MAX_DESCRIPTION_SIZE];
   2814   };
   2815   static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
   2816 
   2817   struct AllocationCallbacks
   2818   {
   2819     AllocationCallbacks( void* pUserData_ = nullptr, PFN_vkAllocationFunction pfnAllocation_ = nullptr, PFN_vkReallocationFunction pfnReallocation_ = nullptr, PFN_vkFreeFunction pfnFree_ = nullptr, PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr, PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
   2820       : pUserData( pUserData_ )
   2821       , pfnAllocation( pfnAllocation_ )
   2822       , pfnReallocation( pfnReallocation_ )
   2823       , pfnFree( pfnFree_ )
   2824       , pfnInternalAllocation( pfnInternalAllocation_ )
   2825       , pfnInternalFree( pfnInternalFree_ )
   2826     {
   2827     }
   2828 
   2829     AllocationCallbacks( VkAllocationCallbacks const & rhs )
   2830     {
   2831       memcpy( this, &rhs, sizeof(AllocationCallbacks) );
   2832     }
   2833 
   2834     AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
   2835     {
   2836       memcpy( this, &rhs, sizeof(AllocationCallbacks) );
   2837       return *this;
   2838     }
   2839 
   2840     AllocationCallbacks& setPUserData( void* pUserData_ )
   2841     {
   2842       pUserData = pUserData_;
   2843       return *this;
   2844     }
   2845 
   2846     AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ )
   2847     {
   2848       pfnAllocation = pfnAllocation_;
   2849       return *this;
   2850     }
   2851 
   2852     AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ )
   2853     {
   2854       pfnReallocation = pfnReallocation_;
   2855       return *this;
   2856     }
   2857 
   2858     AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ )
   2859     {
   2860       pfnFree = pfnFree_;
   2861       return *this;
   2862     }
   2863 
   2864     AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ )
   2865     {
   2866       pfnInternalAllocation = pfnInternalAllocation_;
   2867       return *this;
   2868     }
   2869 
   2870     AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ )
   2871     {
   2872       pfnInternalFree = pfnInternalFree_;
   2873       return *this;
   2874     }
   2875 
   2876     operator const VkAllocationCallbacks&() const
   2877     {
   2878       return *reinterpret_cast<const VkAllocationCallbacks*>(this);
   2879     }
   2880 
   2881     bool operator==( AllocationCallbacks const& rhs ) const
   2882     {
   2883       return ( pUserData == rhs.pUserData )
   2884           && ( pfnAllocation == rhs.pfnAllocation )
   2885           && ( pfnReallocation == rhs.pfnReallocation )
   2886           && ( pfnFree == rhs.pfnFree )
   2887           && ( pfnInternalAllocation == rhs.pfnInternalAllocation )
   2888           && ( pfnInternalFree == rhs.pfnInternalFree );
   2889     }
   2890 
   2891     bool operator!=( AllocationCallbacks const& rhs ) const
   2892     {
   2893       return !operator==( rhs );
   2894     }
   2895 
   2896     void* pUserData;
   2897     PFN_vkAllocationFunction pfnAllocation;
   2898     PFN_vkReallocationFunction pfnReallocation;
   2899     PFN_vkFreeFunction pfnFree;
   2900     PFN_vkInternalAllocationNotification pfnInternalAllocation;
   2901     PFN_vkInternalFreeNotification pfnInternalFree;
   2902   };
   2903   static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
   2904 
   2905   struct MemoryRequirements
   2906   {
   2907     operator const VkMemoryRequirements&() const
   2908     {
   2909       return *reinterpret_cast<const VkMemoryRequirements*>(this);
   2910     }
   2911 
   2912     bool operator==( MemoryRequirements const& rhs ) const
   2913     {
   2914       return ( size == rhs.size )
   2915           && ( alignment == rhs.alignment )
   2916           && ( memoryTypeBits == rhs.memoryTypeBits );
   2917     }
   2918 
   2919     bool operator!=( MemoryRequirements const& rhs ) const
   2920     {
   2921       return !operator==( rhs );
   2922     }
   2923 
   2924     DeviceSize size;
   2925     DeviceSize alignment;
   2926     uint32_t memoryTypeBits;
   2927   };
   2928   static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
   2929 
   2930   struct DescriptorBufferInfo
   2931   {
   2932     DescriptorBufferInfo( Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize range_ = 0 )
   2933       : buffer( buffer_ )
   2934       , offset( offset_ )
   2935       , range( range_ )
   2936     {
   2937     }
   2938 
   2939     DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
   2940     {
   2941       memcpy( this, &rhs, sizeof(DescriptorBufferInfo) );
   2942     }
   2943 
   2944     DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
   2945     {
   2946       memcpy( this, &rhs, sizeof(DescriptorBufferInfo) );
   2947       return *this;
   2948     }
   2949 
   2950     DescriptorBufferInfo& setBuffer( Buffer buffer_ )
   2951     {
   2952       buffer = buffer_;
   2953       return *this;
   2954     }
   2955 
   2956     DescriptorBufferInfo& setOffset( DeviceSize offset_ )
   2957     {
   2958       offset = offset_;
   2959       return *this;
   2960     }
   2961 
   2962     DescriptorBufferInfo& setRange( DeviceSize range_ )
   2963     {
   2964       range = range_;
   2965       return *this;
   2966     }
   2967 
   2968     operator const VkDescriptorBufferInfo&() const
   2969     {
   2970       return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
   2971     }
   2972 
   2973     bool operator==( DescriptorBufferInfo const& rhs ) const
   2974     {
   2975       return ( buffer == rhs.buffer )
   2976           && ( offset == rhs.offset )
   2977           && ( range == rhs.range );
   2978     }
   2979 
   2980     bool operator!=( DescriptorBufferInfo const& rhs ) const
   2981     {
   2982       return !operator==( rhs );
   2983     }
   2984 
   2985     Buffer buffer;
   2986     DeviceSize offset;
   2987     DeviceSize range;
   2988   };
   2989   static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
   2990 
   2991   struct SubresourceLayout
   2992   {
   2993     operator const VkSubresourceLayout&() const
   2994     {
   2995       return *reinterpret_cast<const VkSubresourceLayout*>(this);
   2996     }
   2997 
   2998     bool operator==( SubresourceLayout const& rhs ) const
   2999     {
   3000       return ( offset == rhs.offset )
   3001           && ( size == rhs.size )
   3002           && ( rowPitch == rhs.rowPitch )
   3003           && ( arrayPitch == rhs.arrayPitch )
   3004           && ( depthPitch == rhs.depthPitch );
   3005     }
   3006 
   3007     bool operator!=( SubresourceLayout const& rhs ) const
   3008     {
   3009       return !operator==( rhs );
   3010     }
   3011 
   3012     DeviceSize offset;
   3013     DeviceSize size;
   3014     DeviceSize rowPitch;
   3015     DeviceSize arrayPitch;
   3016     DeviceSize depthPitch;
   3017   };
   3018   static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
   3019 
   3020   struct BufferCopy
   3021   {
   3022     BufferCopy( DeviceSize srcOffset_ = 0, DeviceSize dstOffset_ = 0, DeviceSize size_ = 0 )
   3023       : srcOffset( srcOffset_ )
   3024       , dstOffset( dstOffset_ )
   3025       , size( size_ )
   3026     {
   3027     }
   3028 
   3029     BufferCopy( VkBufferCopy const & rhs )
   3030     {
   3031       memcpy( this, &rhs, sizeof(BufferCopy) );
   3032     }
   3033 
   3034     BufferCopy& operator=( VkBufferCopy const & rhs )
   3035     {
   3036       memcpy( this, &rhs, sizeof(BufferCopy) );
   3037       return *this;
   3038     }
   3039 
   3040     BufferCopy& setSrcOffset( DeviceSize srcOffset_ )
   3041     {
   3042       srcOffset = srcOffset_;
   3043       return *this;
   3044     }
   3045 
   3046     BufferCopy& setDstOffset( DeviceSize dstOffset_ )
   3047     {
   3048       dstOffset = dstOffset_;
   3049       return *this;
   3050     }
   3051 
   3052     BufferCopy& setSize( DeviceSize size_ )
   3053     {
   3054       size = size_;
   3055       return *this;
   3056     }
   3057 
   3058     operator const VkBufferCopy&() const
   3059     {
   3060       return *reinterpret_cast<const VkBufferCopy*>(this);
   3061     }
   3062 
   3063     bool operator==( BufferCopy const& rhs ) const
   3064     {
   3065       return ( srcOffset == rhs.srcOffset )
   3066           && ( dstOffset == rhs.dstOffset )
   3067           && ( size == rhs.size );
   3068     }
   3069 
   3070     bool operator!=( BufferCopy const& rhs ) const
   3071     {
   3072       return !operator==( rhs );
   3073     }
   3074 
   3075     DeviceSize srcOffset;
   3076     DeviceSize dstOffset;
   3077     DeviceSize size;
   3078   };
   3079   static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
   3080 
   3081   struct SpecializationMapEntry
   3082   {
   3083     SpecializationMapEntry( uint32_t constantID_ = 0, uint32_t offset_ = 0, size_t size_ = 0 )
   3084       : constantID( constantID_ )
   3085       , offset( offset_ )
   3086       , size( size_ )
   3087     {
   3088     }
   3089 
   3090     SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
   3091     {
   3092       memcpy( this, &rhs, sizeof(SpecializationMapEntry) );
   3093     }
   3094 
   3095     SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
   3096     {
   3097       memcpy( this, &rhs, sizeof(SpecializationMapEntry) );
   3098       return *this;
   3099     }
   3100 
   3101     SpecializationMapEntry& setConstantID( uint32_t constantID_ )
   3102     {
   3103       constantID = constantID_;
   3104       return *this;
   3105     }
   3106 
   3107     SpecializationMapEntry& setOffset( uint32_t offset_ )
   3108     {
   3109       offset = offset_;
   3110       return *this;
   3111     }
   3112 
   3113     SpecializationMapEntry& setSize( size_t size_ )
   3114     {
   3115       size = size_;
   3116       return *this;
   3117     }
   3118 
   3119     operator const VkSpecializationMapEntry&() const
   3120     {
   3121       return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
   3122     }
   3123 
   3124     bool operator==( SpecializationMapEntry const& rhs ) const
   3125     {
   3126       return ( constantID == rhs.constantID )
   3127           && ( offset == rhs.offset )
   3128           && ( size == rhs.size );
   3129     }
   3130 
   3131     bool operator!=( SpecializationMapEntry const& rhs ) const
   3132     {
   3133       return !operator==( rhs );
   3134     }
   3135 
   3136     uint32_t constantID;
   3137     uint32_t offset;
   3138     size_t size;
   3139   };
   3140   static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
   3141 
   3142   struct SpecializationInfo
   3143   {
   3144     SpecializationInfo( uint32_t mapEntryCount_ = 0, const SpecializationMapEntry* pMapEntries_ = nullptr, size_t dataSize_ = 0, const void* pData_ = nullptr )
   3145       : mapEntryCount( mapEntryCount_ )
   3146       , pMapEntries( pMapEntries_ )
   3147       , dataSize( dataSize_ )
   3148       , pData( pData_ )
   3149     {
   3150     }
   3151 
   3152     SpecializationInfo( VkSpecializationInfo const & rhs )
   3153     {
   3154       memcpy( this, &rhs, sizeof(SpecializationInfo) );
   3155     }
   3156 
   3157     SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
   3158     {
   3159       memcpy( this, &rhs, sizeof(SpecializationInfo) );
   3160       return *this;
   3161     }
   3162 
   3163     SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ )
   3164     {
   3165       mapEntryCount = mapEntryCount_;
   3166       return *this;
   3167     }
   3168 
   3169     SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
   3170     {
   3171       pMapEntries = pMapEntries_;
   3172       return *this;
   3173     }
   3174 
   3175     SpecializationInfo& setDataSize( size_t dataSize_ )
   3176     {
   3177       dataSize = dataSize_;
   3178       return *this;
   3179     }
   3180 
   3181     SpecializationInfo& setPData( const void* pData_ )
   3182     {
   3183       pData = pData_;
   3184       return *this;
   3185     }
   3186 
   3187     operator const VkSpecializationInfo&() const
   3188     {
   3189       return *reinterpret_cast<const VkSpecializationInfo*>(this);
   3190     }
   3191 
   3192     bool operator==( SpecializationInfo const& rhs ) const
   3193     {
   3194       return ( mapEntryCount == rhs.mapEntryCount )
   3195           && ( pMapEntries == rhs.pMapEntries )
   3196           && ( dataSize == rhs.dataSize )
   3197           && ( pData == rhs.pData );
   3198     }
   3199 
   3200     bool operator!=( SpecializationInfo const& rhs ) const
   3201     {
   3202       return !operator==( rhs );
   3203     }
   3204 
   3205     uint32_t mapEntryCount;
   3206     const SpecializationMapEntry* pMapEntries;
   3207     size_t dataSize;
   3208     const void* pData;
   3209   };
   3210   static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
   3211 
   3212   union ClearColorValue
   3213   {
   3214     ClearColorValue( const std::array<float,4>& float32_ = { {0} } )
   3215     {
   3216       memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
   3217     }
   3218 
   3219     ClearColorValue( const std::array<int32_t,4>& int32_ )
   3220     {
   3221       memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
   3222     }
   3223 
   3224     ClearColorValue( const std::array<uint32_t,4>& uint32_ )
   3225     {
   3226       memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
   3227     }
   3228 
   3229     ClearColorValue& setFloat32( std::array<float,4> float32_ )
   3230     {
   3231       memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
   3232       return *this;
   3233     }
   3234 
   3235     ClearColorValue& setInt32( std::array<int32_t,4> int32_ )
   3236     {
   3237       memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
   3238       return *this;
   3239     }
   3240 
   3241     ClearColorValue& setUint32( std::array<uint32_t,4> uint32_ )
   3242     {
   3243       memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
   3244       return *this;
   3245     }
   3246 
   3247     operator VkClearColorValue const& () const
   3248     {
   3249       return *reinterpret_cast<const VkClearColorValue*>(this);
   3250     }
   3251 
   3252     float float32[4];
   3253     int32_t int32[4];
   3254     uint32_t uint32[4];
   3255   };
   3256 
   3257   struct ClearDepthStencilValue
   3258   {
   3259     ClearDepthStencilValue( float depth_ = 0, uint32_t stencil_ = 0 )
   3260       : depth( depth_ )
   3261       , stencil( stencil_ )
   3262     {
   3263     }
   3264 
   3265     ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
   3266     {
   3267       memcpy( this, &rhs, sizeof(ClearDepthStencilValue) );
   3268     }
   3269 
   3270     ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
   3271     {
   3272       memcpy( this, &rhs, sizeof(ClearDepthStencilValue) );
   3273       return *this;
   3274     }
   3275 
   3276     ClearDepthStencilValue& setDepth( float depth_ )
   3277     {
   3278       depth = depth_;
   3279       return *this;
   3280     }
   3281 
   3282     ClearDepthStencilValue& setStencil( uint32_t stencil_ )
   3283     {
   3284       stencil = stencil_;
   3285       return *this;
   3286     }
   3287 
   3288     operator const VkClearDepthStencilValue&() const
   3289     {
   3290       return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
   3291     }
   3292 
   3293     bool operator==( ClearDepthStencilValue const& rhs ) const
   3294     {
   3295       return ( depth == rhs.depth )
   3296           && ( stencil == rhs.stencil );
   3297     }
   3298 
   3299     bool operator!=( ClearDepthStencilValue const& rhs ) const
   3300     {
   3301       return !operator==( rhs );
   3302     }
   3303 
   3304     float depth;
   3305     uint32_t stencil;
   3306   };
   3307   static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
   3308 
   3309   union ClearValue
   3310   {
   3311     ClearValue( ClearColorValue color_ = ClearColorValue() )
   3312     {
   3313       color = color_;
   3314     }
   3315 
   3316     ClearValue( ClearDepthStencilValue depthStencil_ )
   3317     {
   3318       depthStencil = depthStencil_;
   3319     }
   3320 
   3321     ClearValue& setColor( ClearColorValue color_ )
   3322     {
   3323       color = color_;
   3324       return *this;
   3325     }
   3326 
   3327     ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ )
   3328     {
   3329       depthStencil = depthStencil_;
   3330       return *this;
   3331     }
   3332 
   3333     operator VkClearValue const& () const
   3334     {
   3335       return *reinterpret_cast<const VkClearValue*>(this);
   3336     }
   3337 
   3338 #ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
   3339     ClearColorValue color;
   3340     ClearDepthStencilValue depthStencil;
   3341 #else
   3342     VkClearColorValue color;
   3343     VkClearDepthStencilValue depthStencil;
   3344 #endif  // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
   3345   };
   3346 
   3347   struct PhysicalDeviceFeatures
   3348   {
   3349     PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0, Bool32 fullDrawIndexUint32_ = 0, Bool32 imageCubeArray_ = 0, Bool32 independentBlend_ = 0, Bool32 geometryShader_ = 0, Bool32 tessellationShader_ = 0, Bool32 sampleRateShading_ = 0, Bool32 dualSrcBlend_ = 0, Bool32 logicOp_ = 0, Bool32 multiDrawIndirect_ = 0, Bool32 drawIndirectFirstInstance_ = 0, Bool32 depthClamp_ = 0, Bool32 depthBiasClamp_ = 0, Bool32 fillModeNonSolid_ = 0, Bool32 depthBounds_ = 0, Bool32 wideLines_ = 0, Bool32 largePoints_ = 0, Bool32 alphaToOne_ = 0, Bool32 multiViewport_ = 0, Bool32 samplerAnisotropy_ = 0, Bool32 textureCompressionETC2_ = 0, Bool32 textureCompressionASTC_LDR_ = 0, Bool32 textureCompressionBC_ = 0, Bool32 occlusionQueryPrecise_ = 0, Bool32 pipelineStatisticsQuery_ = 0, Bool32 vertexPipelineStoresAndAtomics_ = 0, Bool32 fragmentStoresAndAtomics_ = 0, Bool32 shaderTessellationAndGeometryPointSize_ = 0, Bool32 shaderImageGatherExtended_ = 0, Bool32 shaderStorageImageExtendedFormats_ = 0, Bool32 shaderStorageImageMultisample_ = 0, Bool32 shaderStorageImageReadWithoutFormat_ = 0, Bool32 shaderStorageImageWriteWithoutFormat_ = 0, Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0, Bool32 shaderSampledImageArrayDynamicIndexing_ = 0, Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0, Bool32 shaderStorageImageArrayDynamicIndexing_ = 0, Bool32 shaderClipDistance_ = 0, Bool32 shaderCullDistance_ = 0, Bool32 shaderFloat64_ = 0, Bool32 shaderInt64_ = 0, Bool32 shaderInt16_ = 0, Bool32 shaderResourceResidency_ = 0, Bool32 shaderResourceMinLod_ = 0, Bool32 sparseBinding_ = 0, Bool32 sparseResidencyBuffer_ = 0, Bool32 sparseResidencyImage2D_ = 0, Bool32 sparseResidencyImage3D_ = 0, Bool32 sparseResidency2Samples_ = 0, Bool32 sparseResidency4Samples_ = 0, Bool32 sparseResidency8Samples_ = 0, Bool32 sparseResidency16Samples_ = 0, Bool32 sparseResidencyAliased_ = 0, Bool32 variableMultisampleRate_ = 0, Bool32 inheritedQueries_ = 0 )
   3350       : robustBufferAccess( robustBufferAccess_ )
   3351       , fullDrawIndexUint32( fullDrawIndexUint32_ )
   3352       , imageCubeArray( imageCubeArray_ )
   3353       , independentBlend( independentBlend_ )
   3354       , geometryShader( geometryShader_ )
   3355       , tessellationShader( tessellationShader_ )
   3356       , sampleRateShading( sampleRateShading_ )
   3357       , dualSrcBlend( dualSrcBlend_ )
   3358       , logicOp( logicOp_ )
   3359       , multiDrawIndirect( multiDrawIndirect_ )
   3360       , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
   3361       , depthClamp( depthClamp_ )
   3362       , depthBiasClamp( depthBiasClamp_ )
   3363       , fillModeNonSolid( fillModeNonSolid_ )
   3364       , depthBounds( depthBounds_ )
   3365       , wideLines( wideLines_ )
   3366       , largePoints( largePoints_ )
   3367       , alphaToOne( alphaToOne_ )
   3368       , multiViewport( multiViewport_ )
   3369       , samplerAnisotropy( samplerAnisotropy_ )
   3370       , textureCompressionETC2( textureCompressionETC2_ )
   3371       , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
   3372       , textureCompressionBC( textureCompressionBC_ )
   3373       , occlusionQueryPrecise( occlusionQueryPrecise_ )
   3374       , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
   3375       , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
   3376       , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
   3377       , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
   3378       , shaderImageGatherExtended( shaderImageGatherExtended_ )
   3379       , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
   3380       , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
   3381       , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
   3382       , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
   3383       , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
   3384       , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
   3385       , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
   3386       , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
   3387       , shaderClipDistance( shaderClipDistance_ )
   3388       , shaderCullDistance( shaderCullDistance_ )
   3389       , shaderFloat64( shaderFloat64_ )
   3390       , shaderInt64( shaderInt64_ )
   3391       , shaderInt16( shaderInt16_ )
   3392       , shaderResourceResidency( shaderResourceResidency_ )
   3393       , shaderResourceMinLod( shaderResourceMinLod_ )
   3394       , sparseBinding( sparseBinding_ )
   3395       , sparseResidencyBuffer( sparseResidencyBuffer_ )
   3396       , sparseResidencyImage2D( sparseResidencyImage2D_ )
   3397       , sparseResidencyImage3D( sparseResidencyImage3D_ )
   3398       , sparseResidency2Samples( sparseResidency2Samples_ )
   3399       , sparseResidency4Samples( sparseResidency4Samples_ )
   3400       , sparseResidency8Samples( sparseResidency8Samples_ )
   3401       , sparseResidency16Samples( sparseResidency16Samples_ )
   3402       , sparseResidencyAliased( sparseResidencyAliased_ )
   3403       , variableMultisampleRate( variableMultisampleRate_ )
   3404       , inheritedQueries( inheritedQueries_ )
   3405     {
   3406     }
   3407 
   3408     PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
   3409     {
   3410       memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) );
   3411     }
   3412 
   3413     PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
   3414     {
   3415       memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) );
   3416       return *this;
   3417     }
   3418 
   3419     PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ )
   3420     {
   3421       robustBufferAccess = robustBufferAccess_;
   3422       return *this;
   3423     }
   3424 
   3425     PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
   3426     {
   3427       fullDrawIndexUint32 = fullDrawIndexUint32_;
   3428       return *this;
   3429     }
   3430 
   3431     PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ )
   3432     {
   3433       imageCubeArray = imageCubeArray_;
   3434       return *this;
   3435     }
   3436 
   3437     PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ )
   3438     {
   3439       independentBlend = independentBlend_;
   3440       return *this;
   3441     }
   3442 
   3443     PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ )
   3444     {
   3445       geometryShader = geometryShader_;
   3446       return *this;
   3447     }
   3448 
   3449     PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ )
   3450     {
   3451       tessellationShader = tessellationShader_;
   3452       return *this;
   3453     }
   3454 
   3455     PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ )
   3456     {
   3457       sampleRateShading = sampleRateShading_;
   3458       return *this;
   3459     }
   3460 
   3461     PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ )
   3462     {
   3463       dualSrcBlend = dualSrcBlend_;
   3464       return *this;
   3465     }
   3466 
   3467     PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ )
   3468     {
   3469       logicOp = logicOp_;
   3470       return *this;
   3471     }
   3472 
   3473     PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
   3474     {
   3475       multiDrawIndirect = multiDrawIndirect_;
   3476       return *this;
   3477     }
   3478 
   3479     PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
   3480     {
   3481       drawIndirectFirstInstance = drawIndirectFirstInstance_;
   3482       return *this;
   3483     }
   3484 
   3485     PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ )
   3486     {
   3487       depthClamp = depthClamp_;
   3488       return *this;
   3489     }
   3490 
   3491     PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ )
   3492     {
   3493       depthBiasClamp = depthBiasClamp_;
   3494       return *this;
   3495     }
   3496 
   3497     PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ )
   3498     {
   3499       fillModeNonSolid = fillModeNonSolid_;
   3500       return *this;
   3501     }
   3502 
   3503     PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ )
   3504     {
   3505       depthBounds = depthBounds_;
   3506       return *this;
   3507     }
   3508 
   3509     PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ )
   3510     {
   3511       wideLines = wideLines_;
   3512       return *this;
   3513     }
   3514 
   3515     PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ )
   3516     {
   3517       largePoints = largePoints_;
   3518       return *this;
   3519     }
   3520 
   3521     PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ )
   3522     {
   3523       alphaToOne = alphaToOne_;
   3524       return *this;
   3525     }
   3526 
   3527     PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ )
   3528     {
   3529       multiViewport = multiViewport_;
   3530       return *this;
   3531     }
   3532 
   3533     PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
   3534     {
   3535       samplerAnisotropy = samplerAnisotropy_;
   3536       return *this;
   3537     }
   3538 
   3539     PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
   3540     {
   3541       textureCompressionETC2 = textureCompressionETC2_;
   3542       return *this;
   3543     }
   3544 
   3545     PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
   3546     {
   3547       textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
   3548       return *this;
   3549     }
   3550 
   3551     PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ )
   3552     {
   3553       textureCompressionBC = textureCompressionBC_;
   3554       return *this;
   3555     }
   3556 
   3557     PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
   3558     {
   3559       occlusionQueryPrecise = occlusionQueryPrecise_;
   3560       return *this;
   3561     }
   3562 
   3563     PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
   3564     {
   3565       pipelineStatisticsQuery = pipelineStatisticsQuery_;
   3566       return *this;
   3567     }
   3568 
   3569     PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
   3570     {
   3571       vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
   3572       return *this;
   3573     }
   3574 
   3575     PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
   3576     {
   3577       fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
   3578       return *this;
   3579     }
   3580 
   3581     PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
   3582     {
   3583       shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
   3584       return *this;
   3585     }
   3586 
   3587     PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
   3588     {
   3589       shaderImageGatherExtended = shaderImageGatherExtended_;
   3590       return *this;
   3591     }
   3592 
   3593     PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
   3594     {
   3595       shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
   3596       return *this;
   3597     }
   3598 
   3599     PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
   3600     {
   3601       shaderStorageImageMultisample = shaderStorageImageMultisample_;
   3602       return *this;
   3603     }
   3604 
   3605     PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
   3606     {
   3607       shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
   3608       return *this;
   3609     }
   3610 
   3611     PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
   3612     {
   3613       shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
   3614       return *this;
   3615     }
   3616 
   3617     PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
   3618     {
   3619       shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
   3620       return *this;
   3621     }
   3622 
   3623     PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
   3624     {
   3625       shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
   3626       return *this;
   3627     }
   3628 
   3629     PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
   3630     {
   3631       shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
   3632       return *this;
   3633     }
   3634 
   3635     PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
   3636     {
   3637       shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
   3638       return *this;
   3639     }
   3640 
   3641     PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ )
   3642     {
   3643       shaderClipDistance = shaderClipDistance_;
   3644       return *this;
   3645     }
   3646 
   3647     PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ )
   3648     {
   3649       shaderCullDistance = shaderCullDistance_;
   3650       return *this;
   3651     }
   3652 
   3653     PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ )
   3654     {
   3655       shaderFloat64 = shaderFloat64_;
   3656       return *this;
   3657     }
   3658 
   3659     PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ )
   3660     {
   3661       shaderInt64 = shaderInt64_;
   3662       return *this;
   3663     }
   3664 
   3665     PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ )
   3666     {
   3667       shaderInt16 = shaderInt16_;
   3668       return *this;
   3669     }
   3670 
   3671     PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ )
   3672     {
   3673       shaderResourceResidency = shaderResourceResidency_;
   3674       return *this;
   3675     }
   3676 
   3677     PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
   3678     {
   3679       shaderResourceMinLod = shaderResourceMinLod_;
   3680       return *this;
   3681     }
   3682 
   3683     PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ )
   3684     {
   3685       sparseBinding = sparseBinding_;
   3686       return *this;
   3687     }
   3688 
   3689     PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
   3690     {
   3691       sparseResidencyBuffer = sparseResidencyBuffer_;
   3692       return *this;
   3693     }
   3694 
   3695     PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
   3696     {
   3697       sparseResidencyImage2D = sparseResidencyImage2D_;
   3698       return *this;
   3699     }
   3700 
   3701     PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
   3702     {
   3703       sparseResidencyImage3D = sparseResidencyImage3D_;
   3704       return *this;
   3705     }
   3706 
   3707     PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
   3708     {
   3709       sparseResidency2Samples = sparseResidency2Samples_;
   3710       return *this;
   3711     }
   3712 
   3713     PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
   3714     {
   3715       sparseResidency4Samples = sparseResidency4Samples_;
   3716       return *this;
   3717     }
   3718 
   3719     PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
   3720     {
   3721       sparseResidency8Samples = sparseResidency8Samples_;
   3722       return *this;
   3723     }
   3724 
   3725     PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
   3726     {
   3727       sparseResidency16Samples = sparseResidency16Samples_;
   3728       return *this;
   3729     }
   3730 
   3731     PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
   3732     {
   3733       sparseResidencyAliased = sparseResidencyAliased_;
   3734       return *this;
   3735     }
   3736 
   3737     PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
   3738     {
   3739       variableMultisampleRate = variableMultisampleRate_;
   3740       return *this;
   3741     }
   3742 
   3743     PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ )
   3744     {
   3745       inheritedQueries = inheritedQueries_;
   3746       return *this;
   3747     }
   3748 
   3749     operator const VkPhysicalDeviceFeatures&() const
   3750     {
   3751       return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
   3752     }
   3753 
   3754     bool operator==( PhysicalDeviceFeatures const& rhs ) const
   3755     {
   3756       return ( robustBufferAccess == rhs.robustBufferAccess )
   3757           && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 )
   3758           && ( imageCubeArray == rhs.imageCubeArray )
   3759           && ( independentBlend == rhs.independentBlend )
   3760           && ( geometryShader == rhs.geometryShader )
   3761           && ( tessellationShader == rhs.tessellationShader )
   3762           && ( sampleRateShading == rhs.sampleRateShading )
   3763           && ( dualSrcBlend == rhs.dualSrcBlend )
   3764           && ( logicOp == rhs.logicOp )
   3765           && ( multiDrawIndirect == rhs.multiDrawIndirect )
   3766           && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance )
   3767           && ( depthClamp == rhs.depthClamp )
   3768           && ( depthBiasClamp == rhs.depthBiasClamp )
   3769           && ( fillModeNonSolid == rhs.fillModeNonSolid )
   3770           && ( depthBounds == rhs.depthBounds )
   3771           && ( wideLines == rhs.wideLines )
   3772           && ( largePoints == rhs.largePoints )
   3773           && ( alphaToOne == rhs.alphaToOne )
   3774           && ( multiViewport == rhs.multiViewport )
   3775           && ( samplerAnisotropy == rhs.samplerAnisotropy )
   3776           && ( textureCompressionETC2 == rhs.textureCompressionETC2 )
   3777           && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR )
   3778           && ( textureCompressionBC == rhs.textureCompressionBC )
   3779           && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise )
   3780           && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery )
   3781           && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics )
   3782           && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics )
   3783           && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize )
   3784           && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended )
   3785           && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats )
   3786           && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample )
   3787           && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat )
   3788           && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat )
   3789           && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing )
   3790           && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing )
   3791           && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing )
   3792           && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing )
   3793           && ( shaderClipDistance == rhs.shaderClipDistance )
   3794           && ( shaderCullDistance == rhs.shaderCullDistance )
   3795           && ( shaderFloat64 == rhs.shaderFloat64 )
   3796           && ( shaderInt64 == rhs.shaderInt64 )
   3797           && ( shaderInt16 == rhs.shaderInt16 )
   3798           && ( shaderResourceResidency == rhs.shaderResourceResidency )
   3799           && ( shaderResourceMinLod == rhs.shaderResourceMinLod )
   3800           && ( sparseBinding == rhs.sparseBinding )
   3801           && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer )
   3802           && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D )
   3803           && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D )
   3804           && ( sparseResidency2Samples == rhs.sparseResidency2Samples )
   3805           && ( sparseResidency4Samples == rhs.sparseResidency4Samples )
   3806           && ( sparseResidency8Samples == rhs.sparseResidency8Samples )
   3807           && ( sparseResidency16Samples == rhs.sparseResidency16Samples )
   3808           && ( sparseResidencyAliased == rhs.sparseResidencyAliased )
   3809           && ( variableMultisampleRate == rhs.variableMultisampleRate )
   3810           && ( inheritedQueries == rhs.inheritedQueries );
   3811     }
   3812 
   3813     bool operator!=( PhysicalDeviceFeatures const& rhs ) const
   3814     {
   3815       return !operator==( rhs );
   3816     }
   3817 
   3818     Bool32 robustBufferAccess;
   3819     Bool32 fullDrawIndexUint32;
   3820     Bool32 imageCubeArray;
   3821     Bool32 independentBlend;
   3822     Bool32 geometryShader;
   3823     Bool32 tessellationShader;
   3824     Bool32 sampleRateShading;
   3825     Bool32 dualSrcBlend;
   3826     Bool32 logicOp;
   3827     Bool32 multiDrawIndirect;
   3828     Bool32 drawIndirectFirstInstance;
   3829     Bool32 depthClamp;
   3830     Bool32 depthBiasClamp;
   3831     Bool32 fillModeNonSolid;
   3832     Bool32 depthBounds;
   3833     Bool32 wideLines;
   3834     Bool32 largePoints;
   3835     Bool32 alphaToOne;
   3836     Bool32 multiViewport;
   3837     Bool32 samplerAnisotropy;
   3838     Bool32 textureCompressionETC2;
   3839     Bool32 textureCompressionASTC_LDR;
   3840     Bool32 textureCompressionBC;
   3841     Bool32 occlusionQueryPrecise;
   3842     Bool32 pipelineStatisticsQuery;
   3843     Bool32 vertexPipelineStoresAndAtomics;
   3844     Bool32 fragmentStoresAndAtomics;
   3845     Bool32 shaderTessellationAndGeometryPointSize;
   3846     Bool32 shaderImageGatherExtended;
   3847     Bool32 shaderStorageImageExtendedFormats;
   3848     Bool32 shaderStorageImageMultisample;
   3849     Bool32 shaderStorageImageReadWithoutFormat;
   3850     Bool32 shaderStorageImageWriteWithoutFormat;
   3851     Bool32 shaderUniformBufferArrayDynamicIndexing;
   3852     Bool32 shaderSampledImageArrayDynamicIndexing;
   3853     Bool32 shaderStorageBufferArrayDynamicIndexing;
   3854     Bool32 shaderStorageImageArrayDynamicIndexing;
   3855     Bool32 shaderClipDistance;
   3856     Bool32 shaderCullDistance;
   3857     Bool32 shaderFloat64;
   3858     Bool32 shaderInt64;
   3859     Bool32 shaderInt16;
   3860     Bool32 shaderResourceResidency;
   3861     Bool32 shaderResourceMinLod;
   3862     Bool32 sparseBinding;
   3863     Bool32 sparseResidencyBuffer;
   3864     Bool32 sparseResidencyImage2D;
   3865     Bool32 sparseResidencyImage3D;
   3866     Bool32 sparseResidency2Samples;
   3867     Bool32 sparseResidency4Samples;
   3868     Bool32 sparseResidency8Samples;
   3869     Bool32 sparseResidency16Samples;
   3870     Bool32 sparseResidencyAliased;
   3871     Bool32 variableMultisampleRate;
   3872     Bool32 inheritedQueries;
   3873   };
   3874   static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
   3875 
   3876   struct PhysicalDeviceSparseProperties
   3877   {
   3878     operator const VkPhysicalDeviceSparseProperties&() const
   3879     {
   3880       return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
   3881     }
   3882 
   3883     bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
   3884     {
   3885       return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
   3886           && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape )
   3887           && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape )
   3888           && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize )
   3889           && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
   3890     }
   3891 
   3892     bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const
   3893     {
   3894       return !operator==( rhs );
   3895     }
   3896 
   3897     Bool32 residencyStandard2DBlockShape;
   3898     Bool32 residencyStandard2DMultisampleBlockShape;
   3899     Bool32 residencyStandard3DBlockShape;
   3900     Bool32 residencyAlignedMipSize;
   3901     Bool32 residencyNonResidentStrict;
   3902   };
   3903   static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
   3904 
   3905   struct DrawIndirectCommand
   3906   {
   3907     DrawIndirectCommand( uint32_t vertexCount_ = 0, uint32_t instanceCount_ = 0, uint32_t firstVertex_ = 0, uint32_t firstInstance_ = 0 )
   3908       : vertexCount( vertexCount_ )
   3909       , instanceCount( instanceCount_ )
   3910       , firstVertex( firstVertex_ )
   3911       , firstInstance( firstInstance_ )
   3912     {
   3913     }
   3914 
   3915     DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
   3916     {
   3917       memcpy( this, &rhs, sizeof(DrawIndirectCommand) );
   3918     }
   3919 
   3920     DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
   3921     {
   3922       memcpy( this, &rhs, sizeof(DrawIndirectCommand) );
   3923       return *this;
   3924     }
   3925 
   3926     DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ )
   3927     {
   3928       vertexCount = vertexCount_;
   3929       return *this;
   3930     }
   3931 
   3932     DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
   3933     {
   3934       instanceCount = instanceCount_;
   3935       return *this;
   3936     }
   3937 
   3938     DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ )
   3939     {
   3940       firstVertex = firstVertex_;
   3941       return *this;
   3942     }
   3943 
   3944     DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
   3945     {
   3946       firstInstance = firstInstance_;
   3947       return *this;
   3948     }
   3949 
   3950     operator const VkDrawIndirectCommand&() const
   3951     {
   3952       return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
   3953     }
   3954 
   3955     bool operator==( DrawIndirectCommand const& rhs ) const
   3956     {
   3957       return ( vertexCount == rhs.vertexCount )
   3958           && ( instanceCount == rhs.instanceCount )
   3959           && ( firstVertex == rhs.firstVertex )
   3960           && ( firstInstance == rhs.firstInstance );
   3961     }
   3962 
   3963     bool operator!=( DrawIndirectCommand const& rhs ) const
   3964     {
   3965       return !operator==( rhs );
   3966     }
   3967 
   3968     uint32_t vertexCount;
   3969     uint32_t instanceCount;
   3970     uint32_t firstVertex;
   3971     uint32_t firstInstance;
   3972   };
   3973   static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
   3974 
   3975   struct DrawIndexedIndirectCommand
   3976   {
   3977     DrawIndexedIndirectCommand( uint32_t indexCount_ = 0, uint32_t instanceCount_ = 0, uint32_t firstIndex_ = 0, int32_t vertexOffset_ = 0, uint32_t firstInstance_ = 0 )
   3978       : indexCount( indexCount_ )
   3979       , instanceCount( instanceCount_ )
   3980       , firstIndex( firstIndex_ )
   3981       , vertexOffset( vertexOffset_ )
   3982       , firstInstance( firstInstance_ )
   3983     {
   3984     }
   3985 
   3986     DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
   3987     {
   3988       memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) );
   3989     }
   3990 
   3991     DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
   3992     {
   3993       memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) );
   3994       return *this;
   3995     }
   3996 
   3997     DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ )
   3998     {
   3999       indexCount = indexCount_;
   4000       return *this;
   4001     }
   4002 
   4003     DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
   4004     {
   4005       instanceCount = instanceCount_;
   4006       return *this;
   4007     }
   4008 
   4009     DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ )
   4010     {
   4011       firstIndex = firstIndex_;
   4012       return *this;
   4013     }
   4014 
   4015     DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ )
   4016     {
   4017       vertexOffset = vertexOffset_;
   4018       return *this;
   4019     }
   4020 
   4021     DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
   4022     {
   4023       firstInstance = firstInstance_;
   4024       return *this;
   4025     }
   4026 
   4027     operator const VkDrawIndexedIndirectCommand&() const
   4028     {
   4029       return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
   4030     }
   4031 
   4032     bool operator==( DrawIndexedIndirectCommand const& rhs ) const
   4033     {
   4034       return ( indexCount == rhs.indexCount )
   4035           && ( instanceCount == rhs.instanceCount )
   4036           && ( firstIndex == rhs.firstIndex )
   4037           && ( vertexOffset == rhs.vertexOffset )
   4038           && ( firstInstance == rhs.firstInstance );
   4039     }
   4040 
   4041     bool operator!=( DrawIndexedIndirectCommand const& rhs ) const
   4042     {
   4043       return !operator==( rhs );
   4044     }
   4045 
   4046     uint32_t indexCount;
   4047     uint32_t instanceCount;
   4048     uint32_t firstIndex;
   4049     int32_t vertexOffset;
   4050     uint32_t firstInstance;
   4051   };
   4052   static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
   4053 
   4054   struct DispatchIndirectCommand
   4055   {
   4056     DispatchIndirectCommand( uint32_t x_ = 0, uint32_t y_ = 0, uint32_t z_ = 0 )
   4057       : x( x_ )
   4058       , y( y_ )
   4059       , z( z_ )
   4060     {
   4061     }
   4062 
   4063     DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
   4064     {
   4065       memcpy( this, &rhs, sizeof(DispatchIndirectCommand) );
   4066     }
   4067 
   4068     DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
   4069     {
   4070       memcpy( this, &rhs, sizeof(DispatchIndirectCommand) );
   4071       return *this;
   4072     }
   4073 
   4074     DispatchIndirectCommand& setX( uint32_t x_ )
   4075     {
   4076       x = x_;
   4077       return *this;
   4078     }
   4079 
   4080     DispatchIndirectCommand& setY( uint32_t y_ )
   4081     {
   4082       y = y_;
   4083       return *this;
   4084     }
   4085 
   4086     DispatchIndirectCommand& setZ( uint32_t z_ )
   4087     {
   4088       z = z_;
   4089       return *this;
   4090     }
   4091 
   4092     operator const VkDispatchIndirectCommand&() const
   4093     {
   4094       return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
   4095     }
   4096 
   4097     bool operator==( DispatchIndirectCommand const& rhs ) const
   4098     {
   4099       return ( x == rhs.x )
   4100           && ( y == rhs.y )
   4101           && ( z == rhs.z );
   4102     }
   4103 
   4104     bool operator!=( DispatchIndirectCommand const& rhs ) const
   4105     {
   4106       return !operator==( rhs );
   4107     }
   4108 
   4109     uint32_t x;
   4110     uint32_t y;
   4111     uint32_t z;
   4112   };
   4113   static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
   4114 
   4115   struct DisplayPlanePropertiesKHR
   4116   {
   4117     operator const VkDisplayPlanePropertiesKHR&() const
   4118     {
   4119       return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
   4120     }
   4121 
   4122     bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
   4123     {
   4124       return ( currentDisplay == rhs.currentDisplay )
   4125           && ( currentStackIndex == rhs.currentStackIndex );
   4126     }
   4127 
   4128     bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const
   4129     {
   4130       return !operator==( rhs );
   4131     }
   4132 
   4133     DisplayKHR currentDisplay;
   4134     uint32_t currentStackIndex;
   4135   };
   4136   static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
   4137 
   4138   struct DisplayModeParametersKHR
   4139   {
   4140     DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(), uint32_t refreshRate_ = 0 )
   4141       : visibleRegion( visibleRegion_ )
   4142       , refreshRate( refreshRate_ )
   4143     {
   4144     }
   4145 
   4146     DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
   4147     {
   4148       memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) );
   4149     }
   4150 
   4151     DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
   4152     {
   4153       memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) );
   4154       return *this;
   4155     }
   4156 
   4157     DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ )
   4158     {
   4159       visibleRegion = visibleRegion_;
   4160       return *this;
   4161     }
   4162 
   4163     DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ )
   4164     {
   4165       refreshRate = refreshRate_;
   4166       return *this;
   4167     }
   4168 
   4169     operator const VkDisplayModeParametersKHR&() const
   4170     {
   4171       return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
   4172     }
   4173 
   4174     bool operator==( DisplayModeParametersKHR const& rhs ) const
   4175     {
   4176       return ( visibleRegion == rhs.visibleRegion )
   4177           && ( refreshRate == rhs.refreshRate );
   4178     }
   4179 
   4180     bool operator!=( DisplayModeParametersKHR const& rhs ) const
   4181     {
   4182       return !operator==( rhs );
   4183     }
   4184 
   4185     Extent2D visibleRegion;
   4186     uint32_t refreshRate;
   4187   };
   4188   static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
   4189 
   4190   struct DisplayModePropertiesKHR
   4191   {
   4192     operator const VkDisplayModePropertiesKHR&() const
   4193     {
   4194       return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
   4195     }
   4196 
   4197     bool operator==( DisplayModePropertiesKHR const& rhs ) const
   4198     {
   4199       return ( displayMode == rhs.displayMode )
   4200           && ( parameters == rhs.parameters );
   4201     }
   4202 
   4203     bool operator!=( DisplayModePropertiesKHR const& rhs ) const
   4204     {
   4205       return !operator==( rhs );
   4206     }
   4207 
   4208     DisplayModeKHR displayMode;
   4209     DisplayModeParametersKHR parameters;
   4210   };
   4211   static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
   4212 
   4213   enum class ImageLayout
   4214   {
   4215     eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
   4216     eGeneral = VK_IMAGE_LAYOUT_GENERAL,
   4217     eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   4218     eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   4219     eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
   4220     eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
   4221     eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
   4222     eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
   4223     ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
   4224     ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
   4225   };
   4226 
   4227   struct DescriptorImageInfo
   4228   {
   4229     DescriptorImageInfo( Sampler sampler_ = Sampler(), ImageView imageView_ = ImageView(), ImageLayout imageLayout_ = ImageLayout::eUndefined )
   4230       : sampler( sampler_ )
   4231       , imageView( imageView_ )
   4232       , imageLayout( imageLayout_ )
   4233     {
   4234     }
   4235 
   4236     DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
   4237     {
   4238       memcpy( this, &rhs, sizeof(DescriptorImageInfo) );
   4239     }
   4240 
   4241     DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
   4242     {
   4243       memcpy( this, &rhs, sizeof(DescriptorImageInfo) );
   4244       return *this;
   4245     }
   4246 
   4247     DescriptorImageInfo& setSampler( Sampler sampler_ )
   4248     {
   4249       sampler = sampler_;
   4250       return *this;
   4251     }
   4252 
   4253     DescriptorImageInfo& setImageView( ImageView imageView_ )
   4254     {
   4255       imageView = imageView_;
   4256       return *this;
   4257     }
   4258 
   4259     DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ )
   4260     {
   4261       imageLayout = imageLayout_;
   4262       return *this;
   4263     }
   4264 
   4265     operator const VkDescriptorImageInfo&() const
   4266     {
   4267       return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
   4268     }
   4269 
   4270     bool operator==( DescriptorImageInfo const& rhs ) const
   4271     {
   4272       return ( sampler == rhs.sampler )
   4273           && ( imageView == rhs.imageView )
   4274           && ( imageLayout == rhs.imageLayout );
   4275     }
   4276 
   4277     bool operator!=( DescriptorImageInfo const& rhs ) const
   4278     {
   4279       return !operator==( rhs );
   4280     }
   4281 
   4282     Sampler sampler;
   4283     ImageView imageView;
   4284     ImageLayout imageLayout;
   4285   };
   4286   static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
   4287 
   4288   struct AttachmentReference
   4289   {
   4290     AttachmentReference( uint32_t attachment_ = 0, ImageLayout layout_ = ImageLayout::eUndefined )
   4291       : attachment( attachment_ )
   4292       , layout( layout_ )
   4293     {
   4294     }
   4295 
   4296     AttachmentReference( VkAttachmentReference const & rhs )
   4297     {
   4298       memcpy( this, &rhs, sizeof(AttachmentReference) );
   4299     }
   4300 
   4301     AttachmentReference& operator=( VkAttachmentReference const & rhs )
   4302     {
   4303       memcpy( this, &rhs, sizeof(AttachmentReference) );
   4304       return *this;
   4305     }
   4306 
   4307     AttachmentReference& setAttachment( uint32_t attachment_ )
   4308     {
   4309       attachment = attachment_;
   4310       return *this;
   4311     }
   4312 
   4313     AttachmentReference& setLayout( ImageLayout layout_ )
   4314     {
   4315       layout = layout_;
   4316       return *this;
   4317     }
   4318 
   4319     operator const VkAttachmentReference&() const
   4320     {
   4321       return *reinterpret_cast<const VkAttachmentReference*>(this);
   4322     }
   4323 
   4324     bool operator==( AttachmentReference const& rhs ) const
   4325     {
   4326       return ( attachment == rhs.attachment )
   4327           && ( layout == rhs.layout );
   4328     }
   4329 
   4330     bool operator!=( AttachmentReference const& rhs ) const
   4331     {
   4332       return !operator==( rhs );
   4333     }
   4334 
   4335     uint32_t attachment;
   4336     ImageLayout layout;
   4337   };
   4338   static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
   4339 
   4340   enum class AttachmentLoadOp
   4341   {
   4342     eLoad = VK_ATTACHMENT_LOAD_OP_LOAD,
   4343     eClear = VK_ATTACHMENT_LOAD_OP_CLEAR,
   4344     eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE
   4345   };
   4346 
   4347   enum class AttachmentStoreOp
   4348   {
   4349     eStore = VK_ATTACHMENT_STORE_OP_STORE,
   4350     eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE
   4351   };
   4352 
   4353   enum class ImageType
   4354   {
   4355     e1D = VK_IMAGE_TYPE_1D,
   4356     e2D = VK_IMAGE_TYPE_2D,
   4357     e3D = VK_IMAGE_TYPE_3D
   4358   };
   4359 
   4360   enum class ImageTiling
   4361   {
   4362     eOptimal = VK_IMAGE_TILING_OPTIMAL,
   4363     eLinear = VK_IMAGE_TILING_LINEAR
   4364   };
   4365 
   4366   enum class ImageViewType
   4367   {
   4368     e1D = VK_IMAGE_VIEW_TYPE_1D,
   4369     e2D = VK_IMAGE_VIEW_TYPE_2D,
   4370     e3D = VK_IMAGE_VIEW_TYPE_3D,
   4371     eCube = VK_IMAGE_VIEW_TYPE_CUBE,
   4372     e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
   4373     e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
   4374     eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
   4375   };
   4376 
   4377   enum class CommandBufferLevel
   4378   {
   4379     ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
   4380     eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
   4381   };
   4382 
   4383   enum class ComponentSwizzle
   4384   {
   4385     eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
   4386     eZero = VK_COMPONENT_SWIZZLE_ZERO,
   4387     eOne = VK_COMPONENT_SWIZZLE_ONE,
   4388     eR = VK_COMPONENT_SWIZZLE_R,
   4389     eG = VK_COMPONENT_SWIZZLE_G,
   4390     eB = VK_COMPONENT_SWIZZLE_B,
   4391     eA = VK_COMPONENT_SWIZZLE_A
   4392   };
   4393 
   4394   struct ComponentMapping
   4395   {
   4396     ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, ComponentSwizzle g_ = ComponentSwizzle::eIdentity, ComponentSwizzle b_ = ComponentSwizzle::eIdentity, ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
   4397       : r( r_ )
   4398       , g( g_ )
   4399       , b( b_ )
   4400       , a( a_ )
   4401     {
   4402     }
   4403 
   4404     ComponentMapping( VkComponentMapping const & rhs )
   4405     {
   4406       memcpy( this, &rhs, sizeof(ComponentMapping) );
   4407     }
   4408 
   4409     ComponentMapping& operator=( VkComponentMapping const & rhs )
   4410     {
   4411       memcpy( this, &rhs, sizeof(ComponentMapping) );
   4412       return *this;
   4413     }
   4414 
   4415     ComponentMapping& setR( ComponentSwizzle r_ )
   4416     {
   4417       r = r_;
   4418       return *this;
   4419     }
   4420 
   4421     ComponentMapping& setG( ComponentSwizzle g_ )
   4422     {
   4423       g = g_;
   4424       return *this;
   4425     }
   4426 
   4427     ComponentMapping& setB( ComponentSwizzle b_ )
   4428     {
   4429       b = b_;
   4430       return *this;
   4431     }
   4432 
   4433     ComponentMapping& setA( ComponentSwizzle a_ )
   4434     {
   4435       a = a_;
   4436       return *this;
   4437     }
   4438 
   4439     operator const VkComponentMapping&() const
   4440     {
   4441       return *reinterpret_cast<const VkComponentMapping*>(this);
   4442     }
   4443 
   4444     bool operator==( ComponentMapping const& rhs ) const
   4445     {
   4446       return ( r == rhs.r )
   4447           && ( g == rhs.g )
   4448           && ( b == rhs.b )
   4449           && ( a == rhs.a );
   4450     }
   4451 
   4452     bool operator!=( ComponentMapping const& rhs ) const
   4453     {
   4454       return !operator==( rhs );
   4455     }
   4456 
   4457     ComponentSwizzle r;
   4458     ComponentSwizzle g;
   4459     ComponentSwizzle b;
   4460     ComponentSwizzle a;
   4461   };
   4462   static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
   4463 
   4464   enum class DescriptorType
   4465   {
   4466     eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
   4467     eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
   4468     eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
   4469     eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
   4470     eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
   4471     eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
   4472     eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
   4473     eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
   4474     eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
   4475     eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
   4476     eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
   4477   };
   4478 
   4479   struct DescriptorPoolSize
   4480   {
   4481     DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0 )
   4482       : type( type_ )
   4483       , descriptorCount( descriptorCount_ )
   4484     {
   4485     }
   4486 
   4487     DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
   4488     {
   4489       memcpy( this, &rhs, sizeof(DescriptorPoolSize) );
   4490     }
   4491 
   4492     DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
   4493     {
   4494       memcpy( this, &rhs, sizeof(DescriptorPoolSize) );
   4495       return *this;
   4496     }
   4497 
   4498     DescriptorPoolSize& setType( DescriptorType type_ )
   4499     {
   4500       type = type_;
   4501       return *this;
   4502     }
   4503 
   4504     DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ )
   4505     {
   4506       descriptorCount = descriptorCount_;
   4507       return *this;
   4508     }
   4509 
   4510     operator const VkDescriptorPoolSize&() const
   4511     {
   4512       return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
   4513     }
   4514 
   4515     bool operator==( DescriptorPoolSize const& rhs ) const
   4516     {
   4517       return ( type == rhs.type )
   4518           && ( descriptorCount == rhs.descriptorCount );
   4519     }
   4520 
   4521     bool operator!=( DescriptorPoolSize const& rhs ) const
   4522     {
   4523       return !operator==( rhs );
   4524     }
   4525 
   4526     DescriptorType type;
   4527     uint32_t descriptorCount;
   4528   };
   4529   static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
   4530 
   4531   enum class QueryType
   4532   {
   4533     eOcclusion = VK_QUERY_TYPE_OCCLUSION,
   4534     ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
   4535     eTimestamp = VK_QUERY_TYPE_TIMESTAMP
   4536   };
   4537 
   4538   enum class BorderColor
   4539   {
   4540     eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
   4541     eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
   4542     eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
   4543     eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
   4544     eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
   4545     eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
   4546   };
   4547 
   4548   enum class PipelineBindPoint
   4549   {
   4550     eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
   4551     eCompute = VK_PIPELINE_BIND_POINT_COMPUTE
   4552   };
   4553 
   4554   struct SubpassDescription
   4555   {
   4556     SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, uint32_t inputAttachmentCount_ = 0, const AttachmentReference* pInputAttachments_ = nullptr, uint32_t colorAttachmentCount_ = 0, const AttachmentReference* pColorAttachments_ = nullptr, const AttachmentReference* pResolveAttachments_ = nullptr, const AttachmentReference* pDepthStencilAttachment_ = nullptr, uint32_t preserveAttachmentCount_ = 0, const uint32_t* pPreserveAttachments_ = nullptr )
   4557       : flags( flags_ )
   4558       , pipelineBindPoint( pipelineBindPoint_ )
   4559       , inputAttachmentCount( inputAttachmentCount_ )
   4560       , pInputAttachments( pInputAttachments_ )
   4561       , colorAttachmentCount( colorAttachmentCount_ )
   4562       , pColorAttachments( pColorAttachments_ )
   4563       , pResolveAttachments( pResolveAttachments_ )
   4564       , pDepthStencilAttachment( pDepthStencilAttachment_ )
   4565       , preserveAttachmentCount( preserveAttachmentCount_ )
   4566       , pPreserveAttachments( pPreserveAttachments_ )
   4567     {
   4568     }
   4569 
   4570     SubpassDescription( VkSubpassDescription const & rhs )
   4571     {
   4572       memcpy( this, &rhs, sizeof(SubpassDescription) );
   4573     }
   4574 
   4575     SubpassDescription& operator=( VkSubpassDescription const & rhs )
   4576     {
   4577       memcpy( this, &rhs, sizeof(SubpassDescription) );
   4578       return *this;
   4579     }
   4580 
   4581     SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
   4582     {
   4583       flags = flags_;
   4584       return *this;
   4585     }
   4586 
   4587     SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
   4588     {
   4589       pipelineBindPoint = pipelineBindPoint_;
   4590       return *this;
   4591     }
   4592 
   4593     SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
   4594     {
   4595       inputAttachmentCount = inputAttachmentCount_;
   4596       return *this;
   4597     }
   4598 
   4599     SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
   4600     {
   4601       pInputAttachments = pInputAttachments_;
   4602       return *this;
   4603     }
   4604 
   4605     SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
   4606     {
   4607       colorAttachmentCount = colorAttachmentCount_;
   4608       return *this;
   4609     }
   4610 
   4611     SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
   4612     {
   4613       pColorAttachments = pColorAttachments_;
   4614       return *this;
   4615     }
   4616 
   4617     SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
   4618     {
   4619       pResolveAttachments = pResolveAttachments_;
   4620       return *this;
   4621     }
   4622 
   4623     SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
   4624     {
   4625       pDepthStencilAttachment = pDepthStencilAttachment_;
   4626       return *this;
   4627     }
   4628 
   4629     SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
   4630     {
   4631       preserveAttachmentCount = preserveAttachmentCount_;
   4632       return *this;
   4633     }
   4634 
   4635     SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
   4636     {
   4637       pPreserveAttachments = pPreserveAttachments_;
   4638       return *this;
   4639     }
   4640 
   4641     operator const VkSubpassDescription&() const
   4642     {
   4643       return *reinterpret_cast<const VkSubpassDescription*>(this);
   4644     }
   4645 
   4646     bool operator==( SubpassDescription const& rhs ) const
   4647     {
   4648       return ( flags == rhs.flags )
   4649           && ( pipelineBindPoint == rhs.pipelineBindPoint )
   4650           && ( inputAttachmentCount == rhs.inputAttachmentCount )
   4651           && ( pInputAttachments == rhs.pInputAttachments )
   4652           && ( colorAttachmentCount == rhs.colorAttachmentCount )
   4653           && ( pColorAttachments == rhs.pColorAttachments )
   4654           && ( pResolveAttachments == rhs.pResolveAttachments )
   4655           && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
   4656           && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
   4657           && ( pPreserveAttachments == rhs.pPreserveAttachments );
   4658     }
   4659 
   4660     bool operator!=( SubpassDescription const& rhs ) const
   4661     {
   4662       return !operator==( rhs );
   4663     }
   4664 
   4665     SubpassDescriptionFlags flags;
   4666     PipelineBindPoint pipelineBindPoint;
   4667     uint32_t inputAttachmentCount;
   4668     const AttachmentReference* pInputAttachments;
   4669     uint32_t colorAttachmentCount;
   4670     const AttachmentReference* pColorAttachments;
   4671     const AttachmentReference* pResolveAttachments;
   4672     const AttachmentReference* pDepthStencilAttachment;
   4673     uint32_t preserveAttachmentCount;
   4674     const uint32_t* pPreserveAttachments;
   4675   };
   4676   static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
   4677 
   4678   enum class PipelineCacheHeaderVersion
   4679   {
   4680     eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
   4681   };
   4682 
   4683   enum class PrimitiveTopology
   4684   {
   4685     ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
   4686     eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
   4687     eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
   4688     eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
   4689     eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
   4690     eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
   4691     eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
   4692     eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
   4693     eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
   4694     eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
   4695     ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
   4696   };
   4697 
   4698   enum class SharingMode
   4699   {
   4700     eExclusive = VK_SHARING_MODE_EXCLUSIVE,
   4701     eConcurrent = VK_SHARING_MODE_CONCURRENT
   4702   };
   4703 
   4704   enum class IndexType
   4705   {
   4706     eUint16 = VK_INDEX_TYPE_UINT16,
   4707     eUint32 = VK_INDEX_TYPE_UINT32
   4708   };
   4709 
   4710   enum class Filter
   4711   {
   4712     eNearest = VK_FILTER_NEAREST,
   4713     eLinear = VK_FILTER_LINEAR,
   4714     eCubicIMG = VK_FILTER_CUBIC_IMG
   4715   };
   4716 
   4717   enum class SamplerMipmapMode
   4718   {
   4719     eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
   4720     eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
   4721   };
   4722 
   4723   enum class SamplerAddressMode
   4724   {
   4725     eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
   4726     eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
   4727     eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
   4728     eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
   4729     eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
   4730   };
   4731 
   4732   enum class CompareOp
   4733   {
   4734     eNever = VK_COMPARE_OP_NEVER,
   4735     eLess = VK_COMPARE_OP_LESS,
   4736     eEqual = VK_COMPARE_OP_EQUAL,
   4737     eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
   4738     eGreater = VK_COMPARE_OP_GREATER,
   4739     eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
   4740     eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
   4741     eAlways = VK_COMPARE_OP_ALWAYS
   4742   };
   4743 
   4744   enum class PolygonMode
   4745   {
   4746     eFill = VK_POLYGON_MODE_FILL,
   4747     eLine = VK_POLYGON_MODE_LINE,
   4748     ePoint = VK_POLYGON_MODE_POINT
   4749   };
   4750 
   4751   enum class CullModeFlagBits
   4752   {
   4753     eNone = VK_CULL_MODE_NONE,
   4754     eFront = VK_CULL_MODE_FRONT_BIT,
   4755     eBack = VK_CULL_MODE_BACK_BIT,
   4756     eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
   4757   };
   4758 
   4759   using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;
   4760 
   4761   inline CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
   4762   {
   4763     return CullModeFlags( bit0 ) | bit1;
   4764   }
   4765 
   4766   enum class FrontFace
   4767   {
   4768     eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
   4769     eClockwise = VK_FRONT_FACE_CLOCKWISE
   4770   };
   4771 
   4772   enum class BlendFactor
   4773   {
   4774     eZero = VK_BLEND_FACTOR_ZERO,
   4775     eOne = VK_BLEND_FACTOR_ONE,
   4776     eSrcColor = VK_BLEND_FACTOR_SRC_COLOR,
   4777     eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
   4778     eDstColor = VK_BLEND_FACTOR_DST_COLOR,
   4779     eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
   4780     eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA,
   4781     eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
   4782     eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA,
   4783     eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
   4784     eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR,
   4785     eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
   4786     eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA,
   4787     eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
   4788     eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
   4789     eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR,
   4790     eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
   4791     eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA,
   4792     eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
   4793   };
   4794 
   4795   enum class BlendOp
   4796   {
   4797     eAdd = VK_BLEND_OP_ADD,
   4798     eSubtract = VK_BLEND_OP_SUBTRACT,
   4799     eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT,
   4800     eMin = VK_BLEND_OP_MIN,
   4801     eMax = VK_BLEND_OP_MAX
   4802   };
   4803 
   4804   enum class StencilOp
   4805   {
   4806     eKeep = VK_STENCIL_OP_KEEP,
   4807     eZero = VK_STENCIL_OP_ZERO,
   4808     eReplace = VK_STENCIL_OP_REPLACE,
   4809     eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
   4810     eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
   4811     eInvert = VK_STENCIL_OP_INVERT,
   4812     eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
   4813     eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
   4814   };
   4815 
   4816   struct StencilOpState
   4817   {
   4818     StencilOpState( StencilOp failOp_ = StencilOp::eKeep, StencilOp passOp_ = StencilOp::eKeep, StencilOp depthFailOp_ = StencilOp::eKeep, CompareOp compareOp_ = CompareOp::eNever, uint32_t compareMask_ = 0, uint32_t writeMask_ = 0, uint32_t reference_ = 0 )
   4819       : failOp( failOp_ )
   4820       , passOp( passOp_ )
   4821       , depthFailOp( depthFailOp_ )
   4822       , compareOp( compareOp_ )
   4823       , compareMask( compareMask_ )
   4824       , writeMask( writeMask_ )
   4825       , reference( reference_ )
   4826     {
   4827     }
   4828 
   4829     StencilOpState( VkStencilOpState const & rhs )
   4830     {
   4831       memcpy( this, &rhs, sizeof(StencilOpState) );
   4832     }
   4833 
   4834     StencilOpState& operator=( VkStencilOpState const & rhs )
   4835     {
   4836       memcpy( this, &rhs, sizeof(StencilOpState) );
   4837       return *this;
   4838     }
   4839 
   4840     StencilOpState& setFailOp( StencilOp failOp_ )
   4841     {
   4842       failOp = failOp_;
   4843       return *this;
   4844     }
   4845 
   4846     StencilOpState& setPassOp( StencilOp passOp_ )
   4847     {
   4848       passOp = passOp_;
   4849       return *this;
   4850     }
   4851 
   4852     StencilOpState& setDepthFailOp( StencilOp depthFailOp_ )
   4853     {
   4854       depthFailOp = depthFailOp_;
   4855       return *this;
   4856     }
   4857 
   4858     StencilOpState& setCompareOp( CompareOp compareOp_ )
   4859     {
   4860       compareOp = compareOp_;
   4861       return *this;
   4862     }
   4863 
   4864     StencilOpState& setCompareMask( uint32_t compareMask_ )
   4865     {
   4866       compareMask = compareMask_;
   4867       return *this;
   4868     }
   4869 
   4870     StencilOpState& setWriteMask( uint32_t writeMask_ )
   4871     {
   4872       writeMask = writeMask_;
   4873       return *this;
   4874     }
   4875 
   4876     StencilOpState& setReference( uint32_t reference_ )
   4877     {
   4878       reference = reference_;
   4879       return *this;
   4880     }
   4881 
   4882     operator const VkStencilOpState&() const
   4883     {
   4884       return *reinterpret_cast<const VkStencilOpState*>(this);
   4885     }
   4886 
   4887     bool operator==( StencilOpState const& rhs ) const
   4888     {
   4889       return ( failOp == rhs.failOp )
   4890           && ( passOp == rhs.passOp )
   4891           && ( depthFailOp == rhs.depthFailOp )
   4892           && ( compareOp == rhs.compareOp )
   4893           && ( compareMask == rhs.compareMask )
   4894           && ( writeMask == rhs.writeMask )
   4895           && ( reference == rhs.reference );
   4896     }
   4897 
   4898     bool operator!=( StencilOpState const& rhs ) const
   4899     {
   4900       return !operator==( rhs );
   4901     }
   4902 
   4903     StencilOp failOp;
   4904     StencilOp passOp;
   4905     StencilOp depthFailOp;
   4906     CompareOp compareOp;
   4907     uint32_t compareMask;
   4908     uint32_t writeMask;
   4909     uint32_t reference;
   4910   };
   4911   static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
   4912 
   4913   enum class LogicOp
   4914   {
   4915     eClear = VK_LOGIC_OP_CLEAR,
   4916     eAnd = VK_LOGIC_OP_AND,
   4917     eAndReverse = VK_LOGIC_OP_AND_REVERSE,
   4918     eCopy = VK_LOGIC_OP_COPY,
   4919     eAndInverted = VK_LOGIC_OP_AND_INVERTED,
   4920     eNoOp = VK_LOGIC_OP_NO_OP,
   4921     eXor = VK_LOGIC_OP_XOR,
   4922     eOr = VK_LOGIC_OP_OR,
   4923     eNor = VK_LOGIC_OP_NOR,
   4924     eEquivalent = VK_LOGIC_OP_EQUIVALENT,
   4925     eInvert = VK_LOGIC_OP_INVERT,
   4926     eOrReverse = VK_LOGIC_OP_OR_REVERSE,
   4927     eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
   4928     eOrInverted = VK_LOGIC_OP_OR_INVERTED,
   4929     eNand = VK_LOGIC_OP_NAND,
   4930     eSet = VK_LOGIC_OP_SET
   4931   };
   4932 
   4933   enum class InternalAllocationType
   4934   {
   4935     eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
   4936   };
   4937 
   4938   enum class SystemAllocationScope
   4939   {
   4940     eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
   4941     eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
   4942     eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
   4943     eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
   4944     eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
   4945   };
   4946 
   4947   enum class PhysicalDeviceType
   4948   {
   4949     eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
   4950     eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
   4951     eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
   4952     eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
   4953     eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
   4954   };
   4955 
   4956   enum class VertexInputRate
   4957   {
   4958     eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
   4959     eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
   4960   };
   4961 
   4962   struct VertexInputBindingDescription
   4963   {
   4964     VertexInputBindingDescription( uint32_t binding_ = 0, uint32_t stride_ = 0, VertexInputRate inputRate_ = VertexInputRate::eVertex )
   4965       : binding( binding_ )
   4966       , stride( stride_ )
   4967       , inputRate( inputRate_ )
   4968     {
   4969     }
   4970 
   4971     VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
   4972     {
   4973       memcpy( this, &rhs, sizeof(VertexInputBindingDescription) );
   4974     }
   4975 
   4976     VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
   4977     {
   4978       memcpy( this, &rhs, sizeof(VertexInputBindingDescription) );
   4979       return *this;
   4980     }
   4981 
   4982     VertexInputBindingDescription& setBinding( uint32_t binding_ )
   4983     {
   4984       binding = binding_;
   4985       return *this;
   4986     }
   4987 
   4988     VertexInputBindingDescription& setStride( uint32_t stride_ )
   4989     {
   4990       stride = stride_;
   4991       return *this;
   4992     }
   4993 
   4994     VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ )
   4995     {
   4996       inputRate = inputRate_;
   4997       return *this;
   4998     }
   4999 
   5000     operator const VkVertexInputBindingDescription&() const
   5001     {
   5002       return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
   5003     }
   5004 
   5005     bool operator==( VertexInputBindingDescription const& rhs ) const
   5006     {
   5007       return ( binding == rhs.binding )
   5008           && ( stride == rhs.stride )
   5009           && ( inputRate == rhs.inputRate );
   5010     }
   5011 
   5012     bool operator!=( VertexInputBindingDescription const& rhs ) const
   5013     {
   5014       return !operator==( rhs );
   5015     }
   5016 
   5017     uint32_t binding;
   5018     uint32_t stride;
   5019     VertexInputRate inputRate;
   5020   };
   5021   static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
   5022 
   5023   enum class Format
   5024   {
   5025     eUndefined = VK_FORMAT_UNDEFINED,
   5026     eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8,
   5027     eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16,
   5028     eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16,
   5029     eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16,
   5030     eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16,
   5031     eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16,
   5032     eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16,
   5033     eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16,
   5034     eR8Unorm = VK_FORMAT_R8_UNORM,
   5035     eR8Snorm = VK_FORMAT_R8_SNORM,
   5036     eR8Uscaled = VK_FORMAT_R8_USCALED,
   5037     eR8Sscaled = VK_FORMAT_R8_SSCALED,
   5038     eR8Uint = VK_FORMAT_R8_UINT,
   5039     eR8Sint = VK_FORMAT_R8_SINT,
   5040     eR8Srgb = VK_FORMAT_R8_SRGB,
   5041     eR8G8Unorm = VK_FORMAT_R8G8_UNORM,
   5042     eR8G8Snorm = VK_FORMAT_R8G8_SNORM,
   5043     eR8G8Uscaled = VK_FORMAT_R8G8_USCALED,
   5044     eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED,
   5045     eR8G8Uint = VK_FORMAT_R8G8_UINT,
   5046     eR8G8Sint = VK_FORMAT_R8G8_SINT,
   5047     eR8G8Srgb = VK_FORMAT_R8G8_SRGB,
   5048     eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM,
   5049     eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM,
   5050     eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED,
   5051     eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED,
   5052     eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT,
   5053     eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT,
   5054     eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB,
   5055     eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM,
   5056     eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM,
   5057     eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED,
   5058     eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED,
   5059     eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT,
   5060     eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT,
   5061     eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB,
   5062     eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM,
   5063     eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM,
   5064     eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED,
   5065     eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED,
   5066     eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT,
   5067     eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT,
   5068     eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB,
   5069     eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM,
   5070     eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM,
   5071     eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED,
   5072     eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED,
   5073     eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT,
   5074     eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT,
   5075     eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB,
   5076     eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32,
   5077     eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
   5078     eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32,
   5079     eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
   5080     eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32,
   5081     eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32,
   5082     eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
   5083     eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32,
   5084     eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
   5085     eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32,
   5086     eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
   5087     eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32,
   5088     eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32,
   5089     eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32,
   5090     eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
   5091     eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32,
   5092     eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
   5093     eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32,
   5094     eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32,
   5095     eR16Unorm = VK_FORMAT_R16_UNORM,
   5096     eR16Snorm = VK_FORMAT_R16_SNORM,
   5097     eR16Uscaled = VK_FORMAT_R16_USCALED,
   5098     eR16Sscaled = VK_FORMAT_R16_SSCALED,
   5099     eR16Uint = VK_FORMAT_R16_UINT,
   5100     eR16Sint = VK_FORMAT_R16_SINT,
   5101     eR16Sfloat = VK_FORMAT_R16_SFLOAT,
   5102     eR16G16Unorm = VK_FORMAT_R16G16_UNORM,
   5103     eR16G16Snorm = VK_FORMAT_R16G16_SNORM,
   5104     eR16G16Uscaled = VK_FORMAT_R16G16_USCALED,
   5105     eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED,
   5106     eR16G16Uint = VK_FORMAT_R16G16_UINT,
   5107     eR16G16Sint = VK_FORMAT_R16G16_SINT,
   5108     eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT,
   5109     eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM,
   5110     eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM,
   5111     eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED,
   5112     eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED,
   5113     eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT,
   5114     eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT,
   5115     eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT,
   5116     eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM,
   5117     eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM,
   5118     eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED,
   5119     eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED,
   5120     eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT,
   5121     eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT,
   5122     eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT,
   5123     eR32Uint = VK_FORMAT_R32_UINT,
   5124     eR32Sint = VK_FORMAT_R32_SINT,
   5125     eR32Sfloat = VK_FORMAT_R32_SFLOAT,
   5126     eR32G32Uint = VK_FORMAT_R32G32_UINT,
   5127     eR32G32Sint = VK_FORMAT_R32G32_SINT,
   5128     eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT,
   5129     eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT,
   5130     eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT,
   5131     eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT,
   5132     eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT,
   5133     eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT,
   5134     eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT,
   5135     eR64Uint = VK_FORMAT_R64_UINT,
   5136     eR64Sint = VK_FORMAT_R64_SINT,
   5137     eR64Sfloat = VK_FORMAT_R64_SFLOAT,
   5138     eR64G64Uint = VK_FORMAT_R64G64_UINT,
   5139     eR64G64Sint = VK_FORMAT_R64G64_SINT,
   5140     eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT,
   5141     eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT,
   5142     eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT,
   5143     eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT,
   5144     eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT,
   5145     eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT,
   5146     eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT,
   5147     eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32,
   5148     eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
   5149     eD16Unorm = VK_FORMAT_D16_UNORM,
   5150     eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32,
   5151     eD32Sfloat = VK_FORMAT_D32_SFLOAT,
   5152     eS8Uint = VK_FORMAT_S8_UINT,
   5153     eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT,
   5154     eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT,
   5155     eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT,
   5156     eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK,
   5157     eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK,
   5158     eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
   5159     eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
   5160     eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK,
   5161     eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK,
   5162     eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK,
   5163     eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK,
   5164     eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK,
   5165     eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK,
   5166     eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK,
   5167     eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK,
   5168     eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK,
   5169     eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK,
   5170     eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK,
   5171     eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK,
   5172     eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
   5173     eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
   5174     eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
   5175     eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
   5176     eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
   5177     eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
   5178     eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK,
   5179     eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK,
   5180     eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
   5181     eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
   5182     eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
   5183     eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
   5184     eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
   5185     eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
   5186     eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
   5187     eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
   5188     eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
   5189     eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
   5190     eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
   5191     eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
   5192     eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
   5193     eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
   5194     eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
   5195     eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
   5196     eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
   5197     eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
   5198     eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
   5199     eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
   5200     eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
   5201     eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
   5202     eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
   5203     eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
   5204     eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
   5205     eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
   5206     eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
   5207     eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
   5208     eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
   5209     eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
   5210     ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
   5211     ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
   5212     ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
   5213     ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
   5214     ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
   5215     ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
   5216     ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
   5217     ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG
   5218   };
   5219 
   5220   struct VertexInputAttributeDescription
   5221   {
   5222     VertexInputAttributeDescription( uint32_t location_ = 0, uint32_t binding_ = 0, Format format_ = Format::eUndefined, uint32_t offset_ = 0 )
   5223       : location( location_ )
   5224       , binding( binding_ )
   5225       , format( format_ )
   5226       , offset( offset_ )
   5227     {
   5228     }
   5229 
   5230     VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
   5231     {
   5232       memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) );
   5233     }
   5234 
   5235     VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
   5236     {
   5237       memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) );
   5238       return *this;
   5239     }
   5240 
   5241     VertexInputAttributeDescription& setLocation( uint32_t location_ )
   5242     {
   5243       location = location_;
   5244       return *this;
   5245     }
   5246 
   5247     VertexInputAttributeDescription& setBinding( uint32_t binding_ )
   5248     {
   5249       binding = binding_;
   5250       return *this;
   5251     }
   5252 
   5253     VertexInputAttributeDescription& setFormat( Format format_ )
   5254     {
   5255       format = format_;
   5256       return *this;
   5257     }
   5258 
   5259     VertexInputAttributeDescription& setOffset( uint32_t offset_ )
   5260     {
   5261       offset = offset_;
   5262       return *this;
   5263     }
   5264 
   5265     operator const VkVertexInputAttributeDescription&() const
   5266     {
   5267       return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
   5268     }
   5269 
   5270     bool operator==( VertexInputAttributeDescription const& rhs ) const
   5271     {
   5272       return ( location == rhs.location )
   5273           && ( binding == rhs.binding )
   5274           && ( format == rhs.format )
   5275           && ( offset == rhs.offset );
   5276     }
   5277 
   5278     bool operator!=( VertexInputAttributeDescription const& rhs ) const
   5279     {
   5280       return !operator==( rhs );
   5281     }
   5282 
   5283     uint32_t location;
   5284     uint32_t binding;
   5285     Format format;
   5286     uint32_t offset;
   5287   };
   5288   static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
   5289 
   5290   enum class StructureType
   5291   {
   5292     eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO,
   5293     eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
   5294     eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
   5295     eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
   5296     eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO,
   5297     eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
   5298     eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
   5299     eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
   5300     eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
   5301     eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
   5302     eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
   5303     eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
   5304     eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
   5305     eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
   5306     eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
   5307     eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
   5308     eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
   5309     ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
   5310     ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
   5311     ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
   5312     ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
   5313     ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
   5314     ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
   5315     ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
   5316     ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
   5317     ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
   5318     ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
   5319     ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
   5320     eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
   5321     eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
   5322     ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
   5323     eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
   5324     eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
   5325     eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
   5326     eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
   5327     eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
   5328     eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
   5329     eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
   5330     eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
   5331     eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
   5332     eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
   5333     eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
   5334     eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
   5335     eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
   5336     eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
   5337     eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
   5338     eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
   5339     eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO,
   5340     eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
   5341     eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
   5342     ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
   5343     eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR,
   5344     eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR,
   5345     eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR,
   5346     eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
   5347     eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
   5348     eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
   5349     eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR,
   5350     eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
   5351     eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
   5352     eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
   5353     ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
   5354     eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
   5355     eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
   5356     eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT,
   5357     eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
   5358     eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
   5359     eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
   5360     eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
   5361     eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
   5362     eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
   5363     eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
   5364     eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
   5365     eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
   5366   };
   5367 
   5368   struct ApplicationInfo
   5369   {
   5370     ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 )
   5371       : sType( StructureType::eApplicationInfo )
   5372       , pNext( nullptr )
   5373       , pApplicationName( pApplicationName_ )
   5374       , applicationVersion( applicationVersion_ )
   5375       , pEngineName( pEngineName_ )
   5376       , engineVersion( engineVersion_ )
   5377       , apiVersion( apiVersion_ )
   5378     {
   5379     }
   5380 
   5381     ApplicationInfo( VkApplicationInfo const & rhs )
   5382     {
   5383       memcpy( this, &rhs, sizeof(ApplicationInfo) );
   5384     }
   5385 
   5386     ApplicationInfo& operator=( VkApplicationInfo const & rhs )
   5387     {
   5388       memcpy( this, &rhs, sizeof(ApplicationInfo) );
   5389       return *this;
   5390     }
   5391 
   5392     ApplicationInfo& setSType( StructureType sType_ )
   5393     {
   5394       sType = sType_;
   5395       return *this;
   5396     }
   5397 
   5398     ApplicationInfo& setPNext( const void* pNext_ )
   5399     {
   5400       pNext = pNext_;
   5401       return *this;
   5402     }
   5403 
   5404     ApplicationInfo& setPApplicationName( const char* pApplicationName_ )
   5405     {
   5406       pApplicationName = pApplicationName_;
   5407       return *this;
   5408     }
   5409 
   5410     ApplicationInfo& setApplicationVersion( uint32_t applicationVersion_ )
   5411     {
   5412       applicationVersion = applicationVersion_;
   5413       return *this;
   5414     }
   5415 
   5416     ApplicationInfo& setPEngineName( const char* pEngineName_ )
   5417     {
   5418       pEngineName = pEngineName_;
   5419       return *this;
   5420     }
   5421 
   5422     ApplicationInfo& setEngineVersion( uint32_t engineVersion_ )
   5423     {
   5424       engineVersion = engineVersion_;
   5425       return *this;
   5426     }
   5427 
   5428     ApplicationInfo& setApiVersion( uint32_t apiVersion_ )
   5429     {
   5430       apiVersion = apiVersion_;
   5431       return *this;
   5432     }
   5433 
   5434     operator const VkApplicationInfo&() const
   5435     {
   5436       return *reinterpret_cast<const VkApplicationInfo*>(this);
   5437     }
   5438 
   5439     bool operator==( ApplicationInfo const& rhs ) const
   5440     {
   5441       return ( sType == rhs.sType )
   5442           && ( pNext == rhs.pNext )
   5443           && ( pApplicationName == rhs.pApplicationName )
   5444           && ( applicationVersion == rhs.applicationVersion )
   5445           && ( pEngineName == rhs.pEngineName )
   5446           && ( engineVersion == rhs.engineVersion )
   5447           && ( apiVersion == rhs.apiVersion );
   5448     }
   5449 
   5450     bool operator!=( ApplicationInfo const& rhs ) const
   5451     {
   5452       return !operator==( rhs );
   5453     }
   5454 
   5455   private:
   5456     StructureType sType;
   5457 
   5458   public:
   5459     const void* pNext;
   5460     const char* pApplicationName;
   5461     uint32_t applicationVersion;
   5462     const char* pEngineName;
   5463     uint32_t engineVersion;
   5464     uint32_t apiVersion;
   5465   };
   5466   static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" );
   5467 
   5468   struct DeviceQueueCreateInfo
   5469   {
   5470     DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr )
   5471       : sType( StructureType::eDeviceQueueCreateInfo )
   5472       , pNext( nullptr )
   5473       , flags( flags_ )
   5474       , queueFamilyIndex( queueFamilyIndex_ )
   5475       , queueCount( queueCount_ )
   5476       , pQueuePriorities( pQueuePriorities_ )
   5477     {
   5478     }
   5479 
   5480     DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
   5481     {
   5482       memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) );
   5483     }
   5484 
   5485     DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
   5486     {
   5487       memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) );
   5488       return *this;
   5489     }
   5490 
   5491     DeviceQueueCreateInfo& setSType( StructureType sType_ )
   5492     {
   5493       sType = sType_;
   5494       return *this;
   5495     }
   5496 
   5497     DeviceQueueCreateInfo& setPNext( const void* pNext_ )
   5498     {
   5499       pNext = pNext_;
   5500       return *this;
   5501     }
   5502 
   5503     DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ )
   5504     {
   5505       flags = flags_;
   5506       return *this;
   5507     }
   5508 
   5509     DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
   5510     {
   5511       queueFamilyIndex = queueFamilyIndex_;
   5512       return *this;
   5513     }
   5514 
   5515     DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ )
   5516     {
   5517       queueCount = queueCount_;
   5518       return *this;
   5519     }
   5520 
   5521     DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ )
   5522     {
   5523       pQueuePriorities = pQueuePriorities_;
   5524       return *this;
   5525     }
   5526 
   5527     operator const VkDeviceQueueCreateInfo&() const
   5528     {
   5529       return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
   5530     }
   5531 
   5532     bool operator==( DeviceQueueCreateInfo const& rhs ) const
   5533     {
   5534       return ( sType == rhs.sType )
   5535           && ( pNext == rhs.pNext )
   5536           && ( flags == rhs.flags )
   5537           && ( queueFamilyIndex == rhs.queueFamilyIndex )
   5538           && ( queueCount == rhs.queueCount )
   5539           && ( pQueuePriorities == rhs.pQueuePriorities );
   5540     }
   5541 
   5542     bool operator!=( DeviceQueueCreateInfo const& rhs ) const
   5543     {
   5544       return !operator==( rhs );
   5545     }
   5546 
   5547   private:
   5548     StructureType sType;
   5549 
   5550   public:
   5551     const void* pNext;
   5552     DeviceQueueCreateFlags flags;
   5553     uint32_t queueFamilyIndex;
   5554     uint32_t queueCount;
   5555     const float* pQueuePriorities;
   5556   };
   5557   static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
   5558 
   5559   struct DeviceCreateInfo
   5560   {
   5561     DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
   5562       : sType( StructureType::eDeviceCreateInfo )
   5563       , pNext( nullptr )
   5564       , flags( flags_ )
   5565       , queueCreateInfoCount( queueCreateInfoCount_ )
   5566       , pQueueCreateInfos( pQueueCreateInfos_ )
   5567       , enabledLayerCount( enabledLayerCount_ )
   5568       , ppEnabledLayerNames( ppEnabledLayerNames_ )
   5569       , enabledExtensionCount( enabledExtensionCount_ )
   5570       , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
   5571       , pEnabledFeatures( pEnabledFeatures_ )
   5572     {
   5573     }
   5574 
   5575     DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
   5576     {
   5577       memcpy( this, &rhs, sizeof(DeviceCreateInfo) );
   5578     }
   5579 
   5580     DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
   5581     {
   5582       memcpy( this, &rhs, sizeof(DeviceCreateInfo) );
   5583       return *this;
   5584     }
   5585 
   5586     DeviceCreateInfo& setSType( StructureType sType_ )
   5587     {
   5588       sType = sType_;
   5589       return *this;
   5590     }
   5591 
   5592     DeviceCreateInfo& setPNext( const void* pNext_ )
   5593     {
   5594       pNext = pNext_;
   5595       return *this;
   5596     }
   5597 
   5598     DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ )
   5599     {
   5600       flags = flags_;
   5601       return *this;
   5602     }
   5603 
   5604     DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ )
   5605     {
   5606       queueCreateInfoCount = queueCreateInfoCount_;
   5607       return *this;
   5608     }
   5609 
   5610     DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
   5611     {
   5612       pQueueCreateInfos = pQueueCreateInfos_;
   5613       return *this;
   5614     }
   5615 
   5616     DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
   5617     {
   5618       enabledLayerCount = enabledLayerCount_;
   5619       return *this;
   5620     }
   5621 
   5622     DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
   5623     {
   5624       ppEnabledLayerNames = ppEnabledLayerNames_;
   5625       return *this;
   5626     }
   5627 
   5628     DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
   5629     {
   5630       enabledExtensionCount = enabledExtensionCount_;
   5631       return *this;
   5632     }
   5633 
   5634     DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
   5635     {
   5636       ppEnabledExtensionNames = ppEnabledExtensionNames_;
   5637       return *this;
   5638     }
   5639 
   5640     DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
   5641     {
   5642       pEnabledFeatures = pEnabledFeatures_;
   5643       return *this;
   5644     }
   5645 
   5646     operator const VkDeviceCreateInfo&() const
   5647     {
   5648       return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
   5649     }
   5650 
   5651     bool operator==( DeviceCreateInfo const& rhs ) const
   5652     {
   5653       return ( sType == rhs.sType )
   5654           && ( pNext == rhs.pNext )
   5655           && ( flags == rhs.flags )
   5656           && ( queueCreateInfoCount == rhs.queueCreateInfoCount )
   5657           && ( pQueueCreateInfos == rhs.pQueueCreateInfos )
   5658           && ( enabledLayerCount == rhs.enabledLayerCount )
   5659           && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
   5660           && ( enabledExtensionCount == rhs.enabledExtensionCount )
   5661           && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames )
   5662           && ( pEnabledFeatures == rhs.pEnabledFeatures );
   5663     }
   5664 
   5665     bool operator!=( DeviceCreateInfo const& rhs ) const
   5666     {
   5667       return !operator==( rhs );
   5668     }
   5669 
   5670   private:
   5671     StructureType sType;
   5672 
   5673   public:
   5674     const void* pNext;
   5675     DeviceCreateFlags flags;
   5676     uint32_t queueCreateInfoCount;
   5677     const DeviceQueueCreateInfo* pQueueCreateInfos;
   5678     uint32_t enabledLayerCount;
   5679     const char* const* ppEnabledLayerNames;
   5680     uint32_t enabledExtensionCount;
   5681     const char* const* ppEnabledExtensionNames;
   5682     const PhysicalDeviceFeatures* pEnabledFeatures;
   5683   };
   5684   static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
   5685 
   5686   struct InstanceCreateInfo
   5687   {
   5688     InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), const ApplicationInfo* pApplicationInfo_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr )
   5689       : sType( StructureType::eInstanceCreateInfo )
   5690       , pNext( nullptr )
   5691       , flags( flags_ )
   5692       , pApplicationInfo( pApplicationInfo_ )
   5693       , enabledLayerCount( enabledLayerCount_ )
   5694       , ppEnabledLayerNames( ppEnabledLayerNames_ )
   5695       , enabledExtensionCount( enabledExtensionCount_ )
   5696       , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
   5697     {
   5698     }
   5699 
   5700     InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
   5701     {
   5702       memcpy( this, &rhs, sizeof(InstanceCreateInfo) );
   5703     }
   5704 
   5705     InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
   5706     {
   5707       memcpy( this, &rhs, sizeof(InstanceCreateInfo) );
   5708       return *this;
   5709     }
   5710 
   5711     InstanceCreateInfo& setSType( StructureType sType_ )
   5712     {
   5713       sType = sType_;
   5714       return *this;
   5715     }
   5716 
   5717     InstanceCreateInfo& setPNext( const void* pNext_ )
   5718     {
   5719       pNext = pNext_;
   5720       return *this;
   5721     }
   5722 
   5723     InstanceCreateInfo& setFlags( InstanceCreateFlags flags_ )
   5724     {
   5725       flags = flags_;
   5726       return *this;
   5727     }
   5728 
   5729     InstanceCreateInfo& setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ )
   5730     {
   5731       pApplicationInfo = pApplicationInfo_;
   5732       return *this;
   5733     }
   5734 
   5735     InstanceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
   5736     {
   5737       enabledLayerCount = enabledLayerCount_;
   5738       return *this;
   5739     }
   5740 
   5741     InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
   5742     {
   5743       ppEnabledLayerNames = ppEnabledLayerNames_;
   5744       return *this;
   5745     }
   5746 
   5747     InstanceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
   5748     {
   5749       enabledExtensionCount = enabledExtensionCount_;
   5750       return *this;
   5751     }
   5752 
   5753     InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
   5754     {
   5755       ppEnabledExtensionNames = ppEnabledExtensionNames_;
   5756       return *this;
   5757     }
   5758 
   5759     operator const VkInstanceCreateInfo&() const
   5760     {
   5761       return *reinterpret_cast<const VkInstanceCreateInfo*>(this);
   5762     }
   5763 
   5764     bool operator==( InstanceCreateInfo const& rhs ) const
   5765     {
   5766       return ( sType == rhs.sType )
   5767           && ( pNext == rhs.pNext )
   5768           && ( flags == rhs.flags )
   5769           && ( pApplicationInfo == rhs.pApplicationInfo )
   5770           && ( enabledLayerCount == rhs.enabledLayerCount )
   5771           && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
   5772           && ( enabledExtensionCount == rhs.enabledExtensionCount )
   5773           && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
   5774     }
   5775 
   5776     bool operator!=( InstanceCreateInfo const& rhs ) const
   5777     {
   5778       return !operator==( rhs );
   5779     }
   5780 
   5781   private:
   5782     StructureType sType;
   5783 
   5784   public:
   5785     const void* pNext;
   5786     InstanceCreateFlags flags;
   5787     const ApplicationInfo* pApplicationInfo;
   5788     uint32_t enabledLayerCount;
   5789     const char* const* ppEnabledLayerNames;
   5790     uint32_t enabledExtensionCount;
   5791     const char* const* ppEnabledExtensionNames;
   5792   };
   5793   static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
   5794 
   5795   struct MemoryAllocateInfo
   5796   {
   5797     MemoryAllocateInfo( DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 )
   5798       : sType( StructureType::eMemoryAllocateInfo )
   5799       , pNext( nullptr )
   5800       , allocationSize( allocationSize_ )
   5801       , memoryTypeIndex( memoryTypeIndex_ )
   5802     {
   5803     }
   5804 
   5805     MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
   5806     {
   5807       memcpy( this, &rhs, sizeof(MemoryAllocateInfo) );
   5808     }
   5809 
   5810     MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
   5811     {
   5812       memcpy( this, &rhs, sizeof(MemoryAllocateInfo) );
   5813       return *this;
   5814     }
   5815 
   5816     MemoryAllocateInfo& setSType( StructureType sType_ )
   5817     {
   5818       sType = sType_;
   5819       return *this;
   5820     }
   5821 
   5822     MemoryAllocateInfo& setPNext( const void* pNext_ )
   5823     {
   5824       pNext = pNext_;
   5825       return *this;
   5826     }
   5827 
   5828     MemoryAllocateInfo& setAllocationSize( DeviceSize allocationSize_ )
   5829     {
   5830       allocationSize = allocationSize_;
   5831       return *this;
   5832     }
   5833 
   5834     MemoryAllocateInfo& setMemoryTypeIndex( uint32_t memoryTypeIndex_ )
   5835     {
   5836       memoryTypeIndex = memoryTypeIndex_;
   5837       return *this;
   5838     }
   5839 
   5840     operator const VkMemoryAllocateInfo&() const
   5841     {
   5842       return *reinterpret_cast<const VkMemoryAllocateInfo*>(this);
   5843     }
   5844 
   5845     bool operator==( MemoryAllocateInfo const& rhs ) const
   5846     {
   5847       return ( sType == rhs.sType )
   5848           && ( pNext == rhs.pNext )
   5849           && ( allocationSize == rhs.allocationSize )
   5850           && ( memoryTypeIndex == rhs.memoryTypeIndex );
   5851     }
   5852 
   5853     bool operator!=( MemoryAllocateInfo const& rhs ) const
   5854     {
   5855       return !operator==( rhs );
   5856     }
   5857 
   5858   private:
   5859     StructureType sType;
   5860 
   5861   public:
   5862     const void* pNext;
   5863     DeviceSize allocationSize;
   5864     uint32_t memoryTypeIndex;
   5865   };
   5866   static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
   5867 
   5868   struct MappedMemoryRange
   5869   {
   5870     MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
   5871       : sType( StructureType::eMappedMemoryRange )
   5872       , pNext( nullptr )
   5873       , memory( memory_ )
   5874       , offset( offset_ )
   5875       , size( size_ )
   5876     {
   5877     }
   5878 
   5879     MappedMemoryRange( VkMappedMemoryRange const & rhs )
   5880     {
   5881       memcpy( this, &rhs, sizeof(MappedMemoryRange) );
   5882     }
   5883 
   5884     MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
   5885     {
   5886       memcpy( this, &rhs, sizeof(MappedMemoryRange) );
   5887       return *this;
   5888     }
   5889 
   5890     MappedMemoryRange& setSType( StructureType sType_ )
   5891     {
   5892       sType = sType_;
   5893       return *this;
   5894     }
   5895 
   5896     MappedMemoryRange& setPNext( const void* pNext_ )
   5897     {
   5898       pNext = pNext_;
   5899       return *this;
   5900     }
   5901 
   5902     MappedMemoryRange& setMemory( DeviceMemory memory_ )
   5903     {
   5904       memory = memory_;
   5905       return *this;
   5906     }
   5907 
   5908     MappedMemoryRange& setOffset( DeviceSize offset_ )
   5909     {
   5910       offset = offset_;
   5911       return *this;
   5912     }
   5913 
   5914     MappedMemoryRange& setSize( DeviceSize size_ )
   5915     {
   5916       size = size_;
   5917       return *this;
   5918     }
   5919 
   5920     operator const VkMappedMemoryRange&() const
   5921     {
   5922       return *reinterpret_cast<const VkMappedMemoryRange*>(this);
   5923     }
   5924 
   5925     bool operator==( MappedMemoryRange const& rhs ) const
   5926     {
   5927       return ( sType == rhs.sType )
   5928           && ( pNext == rhs.pNext )
   5929           && ( memory == rhs.memory )
   5930           && ( offset == rhs.offset )
   5931           && ( size == rhs.size );
   5932     }
   5933 
   5934     bool operator!=( MappedMemoryRange const& rhs ) const
   5935     {
   5936       return !operator==( rhs );
   5937     }
   5938 
   5939   private:
   5940     StructureType sType;
   5941 
   5942   public:
   5943     const void* pNext;
   5944     DeviceMemory memory;
   5945     DeviceSize offset;
   5946     DeviceSize size;
   5947   };
   5948   static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
   5949 
   5950   struct WriteDescriptorSet
   5951   {
   5952     WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, const DescriptorImageInfo* pImageInfo_ = nullptr, const DescriptorBufferInfo* pBufferInfo_ = nullptr, const BufferView* pTexelBufferView_ = nullptr )
   5953       : sType( StructureType::eWriteDescriptorSet )
   5954       , pNext( nullptr )
   5955       , dstSet( dstSet_ )
   5956       , dstBinding( dstBinding_ )
   5957       , dstArrayElement( dstArrayElement_ )
   5958       , descriptorCount( descriptorCount_ )
   5959       , descriptorType( descriptorType_ )
   5960       , pImageInfo( pImageInfo_ )
   5961       , pBufferInfo( pBufferInfo_ )
   5962       , pTexelBufferView( pTexelBufferView_ )
   5963     {
   5964     }
   5965 
   5966     WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
   5967     {
   5968       memcpy( this, &rhs, sizeof(WriteDescriptorSet) );
   5969     }
   5970 
   5971     WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
   5972     {
   5973       memcpy( this, &rhs, sizeof(WriteDescriptorSet) );
   5974       return *this;
   5975     }
   5976 
   5977     WriteDescriptorSet& setSType( StructureType sType_ )
   5978     {
   5979       sType = sType_;
   5980       return *this;
   5981     }
   5982 
   5983     WriteDescriptorSet& setPNext( const void* pNext_ )
   5984     {
   5985       pNext = pNext_;
   5986       return *this;
   5987     }
   5988 
   5989     WriteDescriptorSet& setDstSet( DescriptorSet dstSet_ )
   5990     {
   5991       dstSet = dstSet_;
   5992       return *this;
   5993     }
   5994 
   5995     WriteDescriptorSet& setDstBinding( uint32_t dstBinding_ )
   5996     {
   5997       dstBinding = dstBinding_;
   5998       return *this;
   5999     }
   6000 
   6001     WriteDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ )
   6002     {
   6003       dstArrayElement = dstArrayElement_;
   6004       return *this;
   6005     }
   6006 
   6007     WriteDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ )
   6008     {
   6009       descriptorCount = descriptorCount_;
   6010       return *this;
   6011     }
   6012 
   6013     WriteDescriptorSet& setDescriptorType( DescriptorType descriptorType_ )
   6014     {
   6015       descriptorType = descriptorType_;
   6016       return *this;
   6017     }
   6018 
   6019     WriteDescriptorSet& setPImageInfo( const DescriptorImageInfo* pImageInfo_ )
   6020     {
   6021       pImageInfo = pImageInfo_;
   6022       return *this;
   6023     }
   6024 
   6025     WriteDescriptorSet& setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ )
   6026     {
   6027       pBufferInfo = pBufferInfo_;
   6028       return *this;
   6029     }
   6030 
   6031     WriteDescriptorSet& setPTexelBufferView( const BufferView* pTexelBufferView_ )
   6032     {
   6033       pTexelBufferView = pTexelBufferView_;
   6034       return *this;
   6035     }
   6036 
   6037     operator const VkWriteDescriptorSet&() const
   6038     {
   6039       return *reinterpret_cast<const VkWriteDescriptorSet*>(this);
   6040     }
   6041 
   6042     bool operator==( WriteDescriptorSet const& rhs ) const
   6043     {
   6044       return ( sType == rhs.sType )
   6045           && ( pNext == rhs.pNext )
   6046           && ( dstSet == rhs.dstSet )
   6047           && ( dstBinding == rhs.dstBinding )
   6048           && ( dstArrayElement == rhs.dstArrayElement )
   6049           && ( descriptorCount == rhs.descriptorCount )
   6050           && ( descriptorType == rhs.descriptorType )
   6051           && ( pImageInfo == rhs.pImageInfo )
   6052           && ( pBufferInfo == rhs.pBufferInfo )
   6053           && ( pTexelBufferView == rhs.pTexelBufferView );
   6054     }
   6055 
   6056     bool operator!=( WriteDescriptorSet const& rhs ) const
   6057     {
   6058       return !operator==( rhs );
   6059     }
   6060 
   6061   private:
   6062     StructureType sType;
   6063 
   6064   public:
   6065     const void* pNext;
   6066     DescriptorSet dstSet;
   6067     uint32_t dstBinding;
   6068     uint32_t dstArrayElement;
   6069     uint32_t descriptorCount;
   6070     DescriptorType descriptorType;
   6071     const DescriptorImageInfo* pImageInfo;
   6072     const DescriptorBufferInfo* pBufferInfo;
   6073     const BufferView* pTexelBufferView;
   6074   };
   6075   static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
   6076 
   6077   struct CopyDescriptorSet
   6078   {
   6079     CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), uint32_t srcBinding_ = 0, uint32_t srcArrayElement_ = 0, DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 )
   6080       : sType( StructureType::eCopyDescriptorSet )
   6081       , pNext( nullptr )
   6082       , srcSet( srcSet_ )
   6083       , srcBinding( srcBinding_ )
   6084       , srcArrayElement( srcArrayElement_ )
   6085       , dstSet( dstSet_ )
   6086       , dstBinding( dstBinding_ )
   6087       , dstArrayElement( dstArrayElement_ )
   6088       , descriptorCount( descriptorCount_ )
   6089     {
   6090     }
   6091 
   6092     CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
   6093     {
   6094       memcpy( this, &rhs, sizeof(CopyDescriptorSet) );
   6095     }
   6096 
   6097     CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
   6098     {
   6099       memcpy( this, &rhs, sizeof(CopyDescriptorSet) );
   6100       return *this;
   6101     }
   6102 
   6103     CopyDescriptorSet& setSType( StructureType sType_ )
   6104     {
   6105       sType = sType_;
   6106       return *this;
   6107     }
   6108 
   6109     CopyDescriptorSet& setPNext( const void* pNext_ )
   6110     {
   6111       pNext = pNext_;
   6112       return *this;
   6113     }
   6114 
   6115     CopyDescriptorSet& setSrcSet( DescriptorSet srcSet_ )
   6116     {
   6117       srcSet = srcSet_;
   6118       return *this;
   6119     }
   6120 
   6121     CopyDescriptorSet& setSrcBinding( uint32_t srcBinding_ )
   6122     {
   6123       srcBinding = srcBinding_;
   6124       return *this;
   6125     }
   6126 
   6127     CopyDescriptorSet& setSrcArrayElement( uint32_t srcArrayElement_ )
   6128     {
   6129       srcArrayElement = srcArrayElement_;
   6130       return *this;
   6131     }
   6132 
   6133     CopyDescriptorSet& setDstSet( DescriptorSet dstSet_ )
   6134     {
   6135       dstSet = dstSet_;
   6136       return *this;
   6137     }
   6138 
   6139     CopyDescriptorSet& setDstBinding( uint32_t dstBinding_ )
   6140     {
   6141       dstBinding = dstBinding_;
   6142       return *this;
   6143     }
   6144 
   6145     CopyDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ )
   6146     {
   6147       dstArrayElement = dstArrayElement_;
   6148       return *this;
   6149     }
   6150 
   6151     CopyDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ )
   6152     {
   6153       descriptorCount = descriptorCount_;
   6154       return *this;
   6155     }
   6156 
   6157     operator const VkCopyDescriptorSet&() const
   6158     {
   6159       return *reinterpret_cast<const VkCopyDescriptorSet*>(this);
   6160     }
   6161 
   6162     bool operator==( CopyDescriptorSet const& rhs ) const
   6163     {
   6164       return ( sType == rhs.sType )
   6165           && ( pNext == rhs.pNext )
   6166           && ( srcSet == rhs.srcSet )
   6167           && ( srcBinding == rhs.srcBinding )
   6168           && ( srcArrayElement == rhs.srcArrayElement )
   6169           && ( dstSet == rhs.dstSet )
   6170           && ( dstBinding == rhs.dstBinding )
   6171           && ( dstArrayElement == rhs.dstArrayElement )
   6172           && ( descriptorCount == rhs.descriptorCount );
   6173     }
   6174 
   6175     bool operator!=( CopyDescriptorSet const& rhs ) const
   6176     {
   6177       return !operator==( rhs );
   6178     }
   6179 
   6180   private:
   6181     StructureType sType;
   6182 
   6183   public:
   6184     const void* pNext;
   6185     DescriptorSet srcSet;
   6186     uint32_t srcBinding;
   6187     uint32_t srcArrayElement;
   6188     DescriptorSet dstSet;
   6189     uint32_t dstBinding;
   6190     uint32_t dstArrayElement;
   6191     uint32_t descriptorCount;
   6192   };
   6193   static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" );
   6194 
   6195   struct BufferViewCreateInfo
   6196   {
   6197     BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), Buffer buffer_ = Buffer(), Format format_ = Format::eUndefined, DeviceSize offset_ = 0, DeviceSize range_ = 0 )
   6198       : sType( StructureType::eBufferViewCreateInfo )
   6199       , pNext( nullptr )
   6200       , flags( flags_ )
   6201       , buffer( buffer_ )
   6202       , format( format_ )
   6203       , offset( offset_ )
   6204       , range( range_ )
   6205     {
   6206     }
   6207 
   6208     BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
   6209     {
   6210       memcpy( this, &rhs, sizeof(BufferViewCreateInfo) );
   6211     }
   6212 
   6213     BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
   6214     {
   6215       memcpy( this, &rhs, sizeof(BufferViewCreateInfo) );
   6216       return *this;
   6217     }
   6218 
   6219     BufferViewCreateInfo& setSType( StructureType sType_ )
   6220     {
   6221       sType = sType_;
   6222       return *this;
   6223     }
   6224 
   6225     BufferViewCreateInfo& setPNext( const void* pNext_ )
   6226     {
   6227       pNext = pNext_;
   6228       return *this;
   6229     }
   6230 
   6231     BufferViewCreateInfo& setFlags( BufferViewCreateFlags flags_ )
   6232     {
   6233       flags = flags_;
   6234       return *this;
   6235     }
   6236 
   6237     BufferViewCreateInfo& setBuffer( Buffer buffer_ )
   6238     {
   6239       buffer = buffer_;
   6240       return *this;
   6241     }
   6242 
   6243     BufferViewCreateInfo& setFormat( Format format_ )
   6244     {
   6245       format = format_;
   6246       return *this;
   6247     }
   6248 
   6249     BufferViewCreateInfo& setOffset( DeviceSize offset_ )
   6250     {
   6251       offset = offset_;
   6252       return *this;
   6253     }
   6254 
   6255     BufferViewCreateInfo& setRange( DeviceSize range_ )
   6256     {
   6257       range = range_;
   6258       return *this;
   6259     }
   6260 
   6261     operator const VkBufferViewCreateInfo&() const
   6262     {
   6263       return *reinterpret_cast<const VkBufferViewCreateInfo*>(this);
   6264     }
   6265 
   6266     bool operator==( BufferViewCreateInfo const& rhs ) const
   6267     {
   6268       return ( sType == rhs.sType )
   6269           && ( pNext == rhs.pNext )
   6270           && ( flags == rhs.flags )
   6271           && ( buffer == rhs.buffer )
   6272           && ( format == rhs.format )
   6273           && ( offset == rhs.offset )
   6274           && ( range == rhs.range );
   6275     }
   6276 
   6277     bool operator!=( BufferViewCreateInfo const& rhs ) const
   6278     {
   6279       return !operator==( rhs );
   6280     }
   6281 
   6282   private:
   6283     StructureType sType;
   6284 
   6285   public:
   6286     const void* pNext;
   6287     BufferViewCreateFlags flags;
   6288     Buffer buffer;
   6289     Format format;
   6290     DeviceSize offset;
   6291     DeviceSize range;
   6292   };
   6293   static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
   6294 
   6295   struct ShaderModuleCreateInfo
   6296   {
   6297     ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr )
   6298       : sType( StructureType::eShaderModuleCreateInfo )
   6299       , pNext( nullptr )
   6300       , flags( flags_ )
   6301       , codeSize( codeSize_ )
   6302       , pCode( pCode_ )
   6303     {
   6304     }
   6305 
   6306     ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
   6307     {
   6308       memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) );
   6309     }
   6310 
   6311     ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
   6312     {
   6313       memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) );
   6314       return *this;
   6315     }
   6316 
   6317     ShaderModuleCreateInfo& setSType( StructureType sType_ )
   6318     {
   6319       sType = sType_;
   6320       return *this;
   6321     }
   6322 
   6323     ShaderModuleCreateInfo& setPNext( const void* pNext_ )
   6324     {
   6325       pNext = pNext_;
   6326       return *this;
   6327     }
   6328 
   6329     ShaderModuleCreateInfo& setFlags( ShaderModuleCreateFlags flags_ )
   6330     {
   6331       flags = flags_;
   6332       return *this;
   6333     }
   6334 
   6335     ShaderModuleCreateInfo& setCodeSize( size_t codeSize_ )
   6336     {
   6337       codeSize = codeSize_;
   6338       return *this;
   6339     }
   6340 
   6341     ShaderModuleCreateInfo& setPCode( const uint32_t* pCode_ )
   6342     {
   6343       pCode = pCode_;
   6344       return *this;
   6345     }
   6346 
   6347     operator const VkShaderModuleCreateInfo&() const
   6348     {
   6349       return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this);
   6350     }
   6351 
   6352     bool operator==( ShaderModuleCreateInfo const& rhs ) const
   6353     {
   6354       return ( sType == rhs.sType )
   6355           && ( pNext == rhs.pNext )
   6356           && ( flags == rhs.flags )
   6357           && ( codeSize == rhs.codeSize )
   6358           && ( pCode == rhs.pCode );
   6359     }
   6360 
   6361     bool operator!=( ShaderModuleCreateInfo const& rhs ) const
   6362     {
   6363       return !operator==( rhs );
   6364     }
   6365 
   6366   private:
   6367     StructureType sType;
   6368 
   6369   public:
   6370     const void* pNext;
   6371     ShaderModuleCreateFlags flags;
   6372     size_t codeSize;
   6373     const uint32_t* pCode;
   6374   };
   6375   static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
   6376 
   6377   struct DescriptorSetAllocateInfo
   6378   {
   6379     DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), uint32_t descriptorSetCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr )
   6380       : sType( StructureType::eDescriptorSetAllocateInfo )
   6381       , pNext( nullptr )
   6382       , descriptorPool( descriptorPool_ )
   6383       , descriptorSetCount( descriptorSetCount_ )
   6384       , pSetLayouts( pSetLayouts_ )
   6385     {
   6386     }
   6387 
   6388     DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
   6389     {
   6390       memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) );
   6391     }
   6392 
   6393     DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
   6394     {
   6395       memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) );
   6396       return *this;
   6397     }
   6398 
   6399     DescriptorSetAllocateInfo& setSType( StructureType sType_ )
   6400     {
   6401       sType = sType_;
   6402       return *this;
   6403     }
   6404 
   6405     DescriptorSetAllocateInfo& setPNext( const void* pNext_ )
   6406     {
   6407       pNext = pNext_;
   6408       return *this;
   6409     }
   6410 
   6411     DescriptorSetAllocateInfo& setDescriptorPool( DescriptorPool descriptorPool_ )
   6412     {
   6413       descriptorPool = descriptorPool_;
   6414       return *this;
   6415     }
   6416 
   6417     DescriptorSetAllocateInfo& setDescriptorSetCount( uint32_t descriptorSetCount_ )
   6418     {
   6419       descriptorSetCount = descriptorSetCount_;
   6420       return *this;
   6421     }
   6422 
   6423     DescriptorSetAllocateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
   6424     {
   6425       pSetLayouts = pSetLayouts_;
   6426       return *this;
   6427     }
   6428 
   6429     operator const VkDescriptorSetAllocateInfo&() const
   6430     {
   6431       return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this);
   6432     }
   6433 
   6434     bool operator==( DescriptorSetAllocateInfo const& rhs ) const
   6435     {
   6436       return ( sType == rhs.sType )
   6437           && ( pNext == rhs.pNext )
   6438           && ( descriptorPool == rhs.descriptorPool )
   6439           && ( descriptorSetCount == rhs.descriptorSetCount )
   6440           && ( pSetLayouts == rhs.pSetLayouts );
   6441     }
   6442 
   6443     bool operator!=( DescriptorSetAllocateInfo const& rhs ) const
   6444     {
   6445       return !operator==( rhs );
   6446     }
   6447 
   6448   private:
   6449     StructureType sType;
   6450 
   6451   public:
   6452     const void* pNext;
   6453     DescriptorPool descriptorPool;
   6454     uint32_t descriptorSetCount;
   6455     const DescriptorSetLayout* pSetLayouts;
   6456   };
   6457   static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
   6458 
   6459   struct PipelineVertexInputStateCreateInfo
   6460   {
   6461     PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
   6462       : sType( StructureType::ePipelineVertexInputStateCreateInfo )
   6463       , pNext( nullptr )
   6464       , flags( flags_ )
   6465       , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
   6466       , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
   6467       , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
   6468       , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
   6469     {
   6470     }
   6471 
   6472     PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
   6473     {
   6474       memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) );
   6475     }
   6476 
   6477     PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
   6478     {
   6479       memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) );
   6480       return *this;
   6481     }
   6482 
   6483     PipelineVertexInputStateCreateInfo& setSType( StructureType sType_ )
   6484     {
   6485       sType = sType_;
   6486       return *this;
   6487     }
   6488 
   6489     PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ )
   6490     {
   6491       pNext = pNext_;
   6492       return *this;
   6493     }
   6494 
   6495     PipelineVertexInputStateCreateInfo& setFlags( PipelineVertexInputStateCreateFlags flags_ )
   6496     {
   6497       flags = flags_;
   6498       return *this;
   6499     }
   6500 
   6501     PipelineVertexInputStateCreateInfo& setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ )
   6502     {
   6503       vertexBindingDescriptionCount = vertexBindingDescriptionCount_;
   6504       return *this;
   6505     }
   6506 
   6507     PipelineVertexInputStateCreateInfo& setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ )
   6508     {
   6509       pVertexBindingDescriptions = pVertexBindingDescriptions_;
   6510       return *this;
   6511     }
   6512 
   6513     PipelineVertexInputStateCreateInfo& setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ )
   6514     {
   6515       vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_;
   6516       return *this;
   6517     }
   6518 
   6519     PipelineVertexInputStateCreateInfo& setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
   6520     {
   6521       pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
   6522       return *this;
   6523     }
   6524 
   6525     operator const VkPipelineVertexInputStateCreateInfo&() const
   6526     {
   6527       return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this);
   6528     }
   6529 
   6530     bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const
   6531     {
   6532       return ( sType == rhs.sType )
   6533           && ( pNext == rhs.pNext )
   6534           && ( flags == rhs.flags )
   6535           && ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount )
   6536           && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions )
   6537           && ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount )
   6538           && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions );
   6539     }
   6540 
   6541     bool operator!=( PipelineVertexInputStateCreateInfo const& rhs ) const
   6542     {
   6543       return !operator==( rhs );
   6544     }
   6545 
   6546   private:
   6547     StructureType sType;
   6548 
   6549   public:
   6550     const void* pNext;
   6551     PipelineVertexInputStateCreateFlags flags;
   6552     uint32_t vertexBindingDescriptionCount;
   6553     const VertexInputBindingDescription* pVertexBindingDescriptions;
   6554     uint32_t vertexAttributeDescriptionCount;
   6555     const VertexInputAttributeDescription* pVertexAttributeDescriptions;
   6556   };
   6557   static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" );
   6558 
   6559   struct PipelineInputAssemblyStateCreateInfo
   6560   {
   6561     PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_ = PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_ = 0 )
   6562       : sType( StructureType::ePipelineInputAssemblyStateCreateInfo )
   6563       , pNext( nullptr )
   6564       , flags( flags_ )
   6565       , topology( topology_ )
   6566       , primitiveRestartEnable( primitiveRestartEnable_ )
   6567     {
   6568     }
   6569 
   6570     PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
   6571     {
   6572       memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) );
   6573     }
   6574 
   6575     PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
   6576     {
   6577       memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) );
   6578       return *this;
   6579     }
   6580 
   6581     PipelineInputAssemblyStateCreateInfo& setSType( StructureType sType_ )
   6582     {
   6583       sType = sType_;
   6584       return *this;
   6585     }
   6586 
   6587     PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ )
   6588     {
   6589       pNext = pNext_;
   6590       return *this;
   6591     }
   6592 
   6593     PipelineInputAssemblyStateCreateInfo& setFlags( PipelineInputAssemblyStateCreateFlags flags_ )
   6594     {
   6595       flags = flags_;
   6596       return *this;
   6597     }
   6598 
   6599     PipelineInputAssemblyStateCreateInfo& setTopology( PrimitiveTopology topology_ )
   6600     {
   6601       topology = topology_;
   6602       return *this;
   6603     }
   6604 
   6605     PipelineInputAssemblyStateCreateInfo& setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ )
   6606     {
   6607       primitiveRestartEnable = primitiveRestartEnable_;
   6608       return *this;
   6609     }
   6610 
   6611     operator const VkPipelineInputAssemblyStateCreateInfo&() const
   6612     {
   6613       return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this);
   6614     }
   6615 
   6616     bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const
   6617     {
   6618       return ( sType == rhs.sType )
   6619           && ( pNext == rhs.pNext )
   6620           && ( flags == rhs.flags )
   6621           && ( topology == rhs.topology )
   6622           && ( primitiveRestartEnable == rhs.primitiveRestartEnable );
   6623     }
   6624 
   6625     bool operator!=( PipelineInputAssemblyStateCreateInfo const& rhs ) const
   6626     {
   6627       return !operator==( rhs );
   6628     }
   6629 
   6630   private:
   6631     StructureType sType;
   6632 
   6633   public:
   6634     const void* pNext;
   6635     PipelineInputAssemblyStateCreateFlags flags;
   6636     PrimitiveTopology topology;
   6637     Bool32 primitiveRestartEnable;
   6638   };
   6639   static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
   6640 
   6641   struct PipelineTessellationStateCreateInfo
   6642   {
   6643     PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 )
   6644       : sType( StructureType::ePipelineTessellationStateCreateInfo )
   6645       , pNext( nullptr )
   6646       , flags( flags_ )
   6647       , patchControlPoints( patchControlPoints_ )
   6648     {
   6649     }
   6650 
   6651     PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
   6652     {
   6653       memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) );
   6654     }
   6655 
   6656     PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
   6657     {
   6658       memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) );
   6659       return *this;
   6660     }
   6661 
   6662     PipelineTessellationStateCreateInfo& setSType( StructureType sType_ )
   6663     {
   6664       sType = sType_;
   6665       return *this;
   6666     }
   6667 
   6668     PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ )
   6669     {
   6670       pNext = pNext_;
   6671       return *this;
   6672     }
   6673 
   6674     PipelineTessellationStateCreateInfo& setFlags( PipelineTessellationStateCreateFlags flags_ )
   6675     {
   6676       flags = flags_;
   6677       return *this;
   6678     }
   6679 
   6680     PipelineTessellationStateCreateInfo& setPatchControlPoints( uint32_t patchControlPoints_ )
   6681     {
   6682       patchControlPoints = patchControlPoints_;
   6683       return *this;
   6684     }
   6685 
   6686     operator const VkPipelineTessellationStateCreateInfo&() const
   6687     {
   6688       return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this);
   6689     }
   6690 
   6691     bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const
   6692     {
   6693       return ( sType == rhs.sType )
   6694           && ( pNext == rhs.pNext )
   6695           && ( flags == rhs.flags )
   6696           && ( patchControlPoints == rhs.patchControlPoints );
   6697     }
   6698 
   6699     bool operator!=( PipelineTessellationStateCreateInfo const& rhs ) const
   6700     {
   6701       return !operator==( rhs );
   6702     }
   6703 
   6704   private:
   6705     StructureType sType;
   6706 
   6707   public:
   6708     const void* pNext;
   6709     PipelineTessellationStateCreateFlags flags;
   6710     uint32_t patchControlPoints;
   6711   };
   6712   static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
   6713 
   6714   struct PipelineViewportStateCreateInfo
   6715   {
   6716     PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const Rect2D* pScissors_ = nullptr )
   6717       : sType( StructureType::ePipelineViewportStateCreateInfo )
   6718       , pNext( nullptr )
   6719       , flags( flags_ )
   6720       , viewportCount( viewportCount_ )
   6721       , pViewports( pViewports_ )
   6722       , scissorCount( scissorCount_ )
   6723       , pScissors( pScissors_ )
   6724     {
   6725     }
   6726 
   6727     PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
   6728     {
   6729       memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) );
   6730     }
   6731 
   6732     PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
   6733     {
   6734       memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) );
   6735       return *this;
   6736     }
   6737 
   6738     PipelineViewportStateCreateInfo& setSType( StructureType sType_ )
   6739     {
   6740       sType = sType_;
   6741       return *this;
   6742     }
   6743 
   6744     PipelineViewportStateCreateInfo& setPNext( const void* pNext_ )
   6745     {
   6746       pNext = pNext_;
   6747       return *this;
   6748     }
   6749 
   6750     PipelineViewportStateCreateInfo& setFlags( PipelineViewportStateCreateFlags flags_ )
   6751     {
   6752       flags = flags_;
   6753       return *this;
   6754     }
   6755 
   6756     PipelineViewportStateCreateInfo& setViewportCount( uint32_t viewportCount_ )
   6757     {
   6758       viewportCount = viewportCount_;
   6759       return *this;
   6760     }
   6761 
   6762     PipelineViewportStateCreateInfo& setPViewports( const Viewport* pViewports_ )
   6763     {
   6764       pViewports = pViewports_;
   6765       return *this;
   6766     }
   6767 
   6768     PipelineViewportStateCreateInfo& setScissorCount( uint32_t scissorCount_ )
   6769     {
   6770       scissorCount = scissorCount_;
   6771       return *this;
   6772     }
   6773 
   6774     PipelineViewportStateCreateInfo& setPScissors( const Rect2D* pScissors_ )
   6775     {
   6776       pScissors = pScissors_;
   6777       return *this;
   6778     }
   6779 
   6780     operator const VkPipelineViewportStateCreateInfo&() const
   6781     {
   6782       return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this);
   6783     }
   6784 
   6785     bool operator==( PipelineViewportStateCreateInfo const& rhs ) const
   6786     {
   6787       return ( sType == rhs.sType )
   6788           && ( pNext == rhs.pNext )
   6789           && ( flags == rhs.flags )
   6790           && ( viewportCount == rhs.viewportCount )
   6791           && ( pViewports == rhs.pViewports )
   6792           && ( scissorCount == rhs.scissorCount )
   6793           && ( pScissors == rhs.pScissors );
   6794     }
   6795 
   6796     bool operator!=( PipelineViewportStateCreateInfo const& rhs ) const
   6797     {
   6798       return !operator==( rhs );
   6799     }
   6800 
   6801   private:
   6802     StructureType sType;
   6803 
   6804   public:
   6805     const void* pNext;
   6806     PipelineViewportStateCreateFlags flags;
   6807     uint32_t viewportCount;
   6808     const Viewport* pViewports;
   6809     uint32_t scissorCount;
   6810     const Rect2D* pScissors;
   6811   };
   6812   static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" );
   6813 
   6814   struct PipelineRasterizationStateCreateInfo
   6815   {
   6816     PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), Bool32 depthClampEnable_ = 0, Bool32 rasterizerDiscardEnable_ = 0, PolygonMode polygonMode_ = PolygonMode::eFill, CullModeFlags cullMode_ = CullModeFlags(), FrontFace frontFace_ = FrontFace::eCounterClockwise, Bool32 depthBiasEnable_ = 0, float depthBiasConstantFactor_ = 0, float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 )
   6817       : sType( StructureType::ePipelineRasterizationStateCreateInfo )
   6818       , pNext( nullptr )
   6819       , flags( flags_ )
   6820       , depthClampEnable( depthClampEnable_ )
   6821       , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
   6822       , polygonMode( polygonMode_ )
   6823       , cullMode( cullMode_ )
   6824       , frontFace( frontFace_ )
   6825       , depthBiasEnable( depthBiasEnable_ )
   6826       , depthBiasConstantFactor( depthBiasConstantFactor_ )
   6827       , depthBiasClamp( depthBiasClamp_ )
   6828       , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
   6829       , lineWidth( lineWidth_ )
   6830     {
   6831     }
   6832 
   6833     PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
   6834     {
   6835       memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) );
   6836     }
   6837 
   6838     PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
   6839     {
   6840       memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) );
   6841       return *this;
   6842     }
   6843 
   6844     PipelineRasterizationStateCreateInfo& setSType( StructureType sType_ )
   6845     {
   6846       sType = sType_;
   6847       return *this;
   6848     }
   6849 
   6850     PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ )
   6851     {
   6852       pNext = pNext_;
   6853       return *this;
   6854     }
   6855 
   6856     PipelineRasterizationStateCreateInfo& setFlags( PipelineRasterizationStateCreateFlags flags_ )
   6857     {
   6858       flags = flags_;
   6859       return *this;
   6860     }
   6861 
   6862     PipelineRasterizationStateCreateInfo& setDepthClampEnable( Bool32 depthClampEnable_ )
   6863     {
   6864       depthClampEnable = depthClampEnable_;
   6865       return *this;
   6866     }
   6867 
   6868     PipelineRasterizationStateCreateInfo& setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ )
   6869     {
   6870       rasterizerDiscardEnable = rasterizerDiscardEnable_;
   6871       return *this;
   6872     }
   6873 
   6874     PipelineRasterizationStateCreateInfo& setPolygonMode( PolygonMode polygonMode_ )
   6875     {
   6876       polygonMode = polygonMode_;
   6877       return *this;
   6878     }
   6879 
   6880     PipelineRasterizationStateCreateInfo& setCullMode( CullModeFlags cullMode_ )
   6881     {
   6882       cullMode = cullMode_;
   6883       return *this;
   6884     }
   6885 
   6886     PipelineRasterizationStateCreateInfo& setFrontFace( FrontFace frontFace_ )
   6887     {
   6888       frontFace = frontFace_;
   6889       return *this;
   6890     }
   6891 
   6892     PipelineRasterizationStateCreateInfo& setDepthBiasEnable( Bool32 depthBiasEnable_ )
   6893     {
   6894       depthBiasEnable = depthBiasEnable_;
   6895       return *this;
   6896     }
   6897 
   6898     PipelineRasterizationStateCreateInfo& setDepthBiasConstantFactor( float depthBiasConstantFactor_ )
   6899     {
   6900       depthBiasConstantFactor = depthBiasConstantFactor_;
   6901       return *this;
   6902     }
   6903 
   6904     PipelineRasterizationStateCreateInfo& setDepthBiasClamp( float depthBiasClamp_ )
   6905     {
   6906       depthBiasClamp = depthBiasClamp_;
   6907       return *this;
   6908     }
   6909 
   6910     PipelineRasterizationStateCreateInfo& setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ )
   6911     {
   6912       depthBiasSlopeFactor = depthBiasSlopeFactor_;
   6913       return *this;
   6914     }
   6915 
   6916     PipelineRasterizationStateCreateInfo& setLineWidth( float lineWidth_ )
   6917     {
   6918       lineWidth = lineWidth_;
   6919       return *this;
   6920     }
   6921 
   6922     operator const VkPipelineRasterizationStateCreateInfo&() const
   6923     {
   6924       return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this);
   6925     }
   6926 
   6927     bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const
   6928     {
   6929       return ( sType == rhs.sType )
   6930           && ( pNext == rhs.pNext )
   6931           && ( flags == rhs.flags )
   6932           && ( depthClampEnable == rhs.depthClampEnable )
   6933           && ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable )
   6934           && ( polygonMode == rhs.polygonMode )
   6935           && ( cullMode == rhs.cullMode )
   6936           && ( frontFace == rhs.frontFace )
   6937           && ( depthBiasEnable == rhs.depthBiasEnable )
   6938           && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor )
   6939           && ( depthBiasClamp == rhs.depthBiasClamp )
   6940           && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor )
   6941           && ( lineWidth == rhs.lineWidth );
   6942     }
   6943 
   6944     bool operator!=( PipelineRasterizationStateCreateInfo const& rhs ) const
   6945     {
   6946       return !operator==( rhs );
   6947     }
   6948 
   6949   private:
   6950     StructureType sType;
   6951 
   6952   public:
   6953     const void* pNext;
   6954     PipelineRasterizationStateCreateFlags flags;
   6955     Bool32 depthClampEnable;
   6956     Bool32 rasterizerDiscardEnable;
   6957     PolygonMode polygonMode;
   6958     CullModeFlags cullMode;
   6959     FrontFace frontFace;
   6960     Bool32 depthBiasEnable;
   6961     float depthBiasConstantFactor;
   6962     float depthBiasClamp;
   6963     float depthBiasSlopeFactor;
   6964     float lineWidth;
   6965   };
   6966   static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
   6967 
   6968   struct PipelineDepthStencilStateCreateInfo
   6969   {
   6970     PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), Bool32 depthTestEnable_ = 0, Bool32 depthWriteEnable_ = 0, CompareOp depthCompareOp_ = CompareOp::eNever, Bool32 depthBoundsTestEnable_ = 0, Bool32 stencilTestEnable_ = 0, StencilOpState front_ = StencilOpState(), StencilOpState back_ = StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 )
   6971       : sType( StructureType::ePipelineDepthStencilStateCreateInfo )
   6972       , pNext( nullptr )
   6973       , flags( flags_ )
   6974       , depthTestEnable( depthTestEnable_ )
   6975       , depthWriteEnable( depthWriteEnable_ )
   6976       , depthCompareOp( depthCompareOp_ )
   6977       , depthBoundsTestEnable( depthBoundsTestEnable_ )
   6978       , stencilTestEnable( stencilTestEnable_ )
   6979       , front( front_ )
   6980       , back( back_ )
   6981       , minDepthBounds( minDepthBounds_ )
   6982       , maxDepthBounds( maxDepthBounds_ )
   6983     {
   6984     }
   6985 
   6986     PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
   6987     {
   6988       memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) );
   6989     }
   6990 
   6991     PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
   6992     {
   6993       memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) );
   6994       return *this;
   6995     }
   6996 
   6997     PipelineDepthStencilStateCreateInfo& setSType( StructureType sType_ )
   6998     {
   6999       sType = sType_;
   7000       return *this;
   7001     }
   7002 
   7003     PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ )
   7004     {
   7005       pNext = pNext_;
   7006       return *this;
   7007     }
   7008 
   7009     PipelineDepthStencilStateCreateInfo& setFlags( PipelineDepthStencilStateCreateFlags flags_ )
   7010     {
   7011       flags = flags_;
   7012       return *this;
   7013     }
   7014 
   7015     PipelineDepthStencilStateCreateInfo& setDepthTestEnable( Bool32 depthTestEnable_ )
   7016     {
   7017       depthTestEnable = depthTestEnable_;
   7018       return *this;
   7019     }
   7020 
   7021     PipelineDepthStencilStateCreateInfo& setDepthWriteEnable( Bool32 depthWriteEnable_ )
   7022     {
   7023       depthWriteEnable = depthWriteEnable_;
   7024       return *this;
   7025     }
   7026 
   7027     PipelineDepthStencilStateCreateInfo& setDepthCompareOp( CompareOp depthCompareOp_ )
   7028     {
   7029       depthCompareOp = depthCompareOp_;
   7030       return *this;
   7031     }
   7032 
   7033     PipelineDepthStencilStateCreateInfo& setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ )
   7034     {
   7035       depthBoundsTestEnable = depthBoundsTestEnable_;
   7036       return *this;
   7037     }
   7038 
   7039     PipelineDepthStencilStateCreateInfo& setStencilTestEnable( Bool32 stencilTestEnable_ )
   7040     {
   7041       stencilTestEnable = stencilTestEnable_;
   7042       return *this;
   7043     }
   7044 
   7045     PipelineDepthStencilStateCreateInfo& setFront( StencilOpState front_ )
   7046     {
   7047       front = front_;
   7048       return *this;
   7049     }
   7050 
   7051     PipelineDepthStencilStateCreateInfo& setBack( StencilOpState back_ )
   7052     {
   7053       back = back_;
   7054       return *this;
   7055     }
   7056 
   7057     PipelineDepthStencilStateCreateInfo& setMinDepthBounds( float minDepthBounds_ )
   7058     {
   7059       minDepthBounds = minDepthBounds_;
   7060       return *this;
   7061     }
   7062 
   7063     PipelineDepthStencilStateCreateInfo& setMaxDepthBounds( float maxDepthBounds_ )
   7064     {
   7065       maxDepthBounds = maxDepthBounds_;
   7066       return *this;
   7067     }
   7068 
   7069     operator const VkPipelineDepthStencilStateCreateInfo&() const
   7070     {
   7071       return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this);
   7072     }
   7073 
   7074     bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const
   7075     {
   7076       return ( sType == rhs.sType )
   7077           && ( pNext == rhs.pNext )
   7078           && ( flags == rhs.flags )
   7079           && ( depthTestEnable == rhs.depthTestEnable )
   7080           && ( depthWriteEnable == rhs.depthWriteEnable )
   7081           && ( depthCompareOp == rhs.depthCompareOp )
   7082           && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable )
   7083           && ( stencilTestEnable == rhs.stencilTestEnable )
   7084           && ( front == rhs.front )
   7085           && ( back == rhs.back )
   7086           && ( minDepthBounds == rhs.minDepthBounds )
   7087           && ( maxDepthBounds == rhs.maxDepthBounds );
   7088     }
   7089 
   7090     bool operator!=( PipelineDepthStencilStateCreateInfo const& rhs ) const
   7091     {
   7092       return !operator==( rhs );
   7093     }
   7094 
   7095   private:
   7096     StructureType sType;
   7097 
   7098   public:
   7099     const void* pNext;
   7100     PipelineDepthStencilStateCreateFlags flags;
   7101     Bool32 depthTestEnable;
   7102     Bool32 depthWriteEnable;
   7103     CompareOp depthCompareOp;
   7104     Bool32 depthBoundsTestEnable;
   7105     Bool32 stencilTestEnable;
   7106     StencilOpState front;
   7107     StencilOpState back;
   7108     float minDepthBounds;
   7109     float maxDepthBounds;
   7110   };
   7111   static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
   7112 
   7113   struct PipelineCacheCreateInfo
   7114   {
   7115     PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
   7116       : sType( StructureType::ePipelineCacheCreateInfo )
   7117       , pNext( nullptr )
   7118       , flags( flags_ )
   7119       , initialDataSize( initialDataSize_ )
   7120       , pInitialData( pInitialData_ )
   7121     {
   7122     }
   7123 
   7124     PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
   7125     {
   7126       memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) );
   7127     }
   7128 
   7129     PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
   7130     {
   7131       memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) );
   7132       return *this;
   7133     }
   7134 
   7135     PipelineCacheCreateInfo& setSType( StructureType sType_ )
   7136     {
   7137       sType = sType_;
   7138       return *this;
   7139     }
   7140 
   7141     PipelineCacheCreateInfo& setPNext( const void* pNext_ )
   7142     {
   7143       pNext = pNext_;
   7144       return *this;
   7145     }
   7146 
   7147     PipelineCacheCreateInfo& setFlags( PipelineCacheCreateFlags flags_ )
   7148     {
   7149       flags = flags_;
   7150       return *this;
   7151     }
   7152 
   7153     PipelineCacheCreateInfo& setInitialDataSize( size_t initialDataSize_ )
   7154     {
   7155       initialDataSize = initialDataSize_;
   7156       return *this;
   7157     }
   7158 
   7159     PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ )
   7160     {
   7161       pInitialData = pInitialData_;
   7162       return *this;
   7163     }
   7164 
   7165     operator const VkPipelineCacheCreateInfo&() const
   7166     {
   7167       return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this);
   7168     }
   7169 
   7170     bool operator==( PipelineCacheCreateInfo const& rhs ) const
   7171     {
   7172       return ( sType == rhs.sType )
   7173           && ( pNext == rhs.pNext )
   7174           && ( flags == rhs.flags )
   7175           && ( initialDataSize == rhs.initialDataSize )
   7176           && ( pInitialData == rhs.pInitialData );
   7177     }
   7178 
   7179     bool operator!=( PipelineCacheCreateInfo const& rhs ) const
   7180     {
   7181       return !operator==( rhs );
   7182     }
   7183 
   7184   private:
   7185     StructureType sType;
   7186 
   7187   public:
   7188     const void* pNext;
   7189     PipelineCacheCreateFlags flags;
   7190     size_t initialDataSize;
   7191     const void* pInitialData;
   7192   };
   7193   static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
   7194 
   7195   struct SamplerCreateInfo
   7196   {
   7197     SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), Filter magFilter_ = Filter::eNearest, Filter minFilter_ = Filter::eNearest, SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, float mipLodBias_ = 0, Bool32 anisotropyEnable_ = 0, float maxAnisotropy_ = 0, Bool32 compareEnable_ = 0, CompareOp compareOp_ = CompareOp::eNever, float minLod_ = 0, float maxLod_ = 0, BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, Bool32 unnormalizedCoordinates_ = 0 )
   7198       : sType( StructureType::eSamplerCreateInfo )
   7199       , pNext( nullptr )
   7200       , flags( flags_ )
   7201       , magFilter( magFilter_ )
   7202       , minFilter( minFilter_ )
   7203       , mipmapMode( mipmapMode_ )
   7204       , addressModeU( addressModeU_ )
   7205       , addressModeV( addressModeV_ )
   7206       , addressModeW( addressModeW_ )
   7207       , mipLodBias( mipLodBias_ )
   7208       , anisotropyEnable( anisotropyEnable_ )
   7209       , maxAnisotropy( maxAnisotropy_ )
   7210       , compareEnable( compareEnable_ )
   7211       , compareOp( compareOp_ )
   7212       , minLod( minLod_ )
   7213       , maxLod( maxLod_ )
   7214       , borderColor( borderColor_ )
   7215       , unnormalizedCoordinates( unnormalizedCoordinates_ )
   7216     {
   7217     }
   7218 
   7219     SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
   7220     {
   7221       memcpy( this, &rhs, sizeof(SamplerCreateInfo) );
   7222     }
   7223 
   7224     SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
   7225     {
   7226       memcpy( this, &rhs, sizeof(SamplerCreateInfo) );
   7227       return *this;
   7228     }
   7229 
   7230     SamplerCreateInfo& setSType( StructureType sType_ )
   7231     {
   7232       sType = sType_;
   7233       return *this;
   7234     }
   7235 
   7236     SamplerCreateInfo& setPNext( const void* pNext_ )
   7237     {
   7238       pNext = pNext_;
   7239       return *this;
   7240     }
   7241 
   7242     SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ )
   7243     {
   7244       flags = flags_;
   7245       return *this;
   7246     }
   7247 
   7248     SamplerCreateInfo& setMagFilter( Filter magFilter_ )
   7249     {
   7250       magFilter = magFilter_;
   7251       return *this;
   7252     }
   7253 
   7254     SamplerCreateInfo& setMinFilter( Filter minFilter_ )
   7255     {
   7256       minFilter = minFilter_;
   7257       return *this;
   7258     }
   7259 
   7260     SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ )
   7261     {
   7262       mipmapMode = mipmapMode_;
   7263       return *this;
   7264     }
   7265 
   7266     SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ )
   7267     {
   7268       addressModeU = addressModeU_;
   7269       return *this;
   7270     }
   7271 
   7272     SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ )
   7273     {
   7274       addressModeV = addressModeV_;
   7275       return *this;
   7276     }
   7277 
   7278     SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ )
   7279     {
   7280       addressModeW = addressModeW_;
   7281       return *this;
   7282     }
   7283 
   7284     SamplerCreateInfo& setMipLodBias( float mipLodBias_ )
   7285     {
   7286       mipLodBias = mipLodBias_;
   7287       return *this;
   7288     }
   7289 
   7290     SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ )
   7291     {
   7292       anisotropyEnable = anisotropyEnable_;
   7293       return *this;
   7294     }
   7295 
   7296     SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ )
   7297     {
   7298       maxAnisotropy = maxAnisotropy_;
   7299       return *this;
   7300     }
   7301 
   7302     SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ )
   7303     {
   7304       compareEnable = compareEnable_;
   7305       return *this;
   7306     }
   7307 
   7308     SamplerCreateInfo& setCompareOp( CompareOp compareOp_ )
   7309     {
   7310       compareOp = compareOp_;
   7311       return *this;
   7312     }
   7313 
   7314     SamplerCreateInfo& setMinLod( float minLod_ )
   7315     {
   7316       minLod = minLod_;
   7317       return *this;
   7318     }
   7319 
   7320     SamplerCreateInfo& setMaxLod( float maxLod_ )
   7321     {
   7322       maxLod = maxLod_;
   7323       return *this;
   7324     }
   7325 
   7326     SamplerCreateInfo& setBorderColor( BorderColor borderColor_ )
   7327     {
   7328       borderColor = borderColor_;
   7329       return *this;
   7330     }
   7331 
   7332     SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ )
   7333     {
   7334       unnormalizedCoordinates = unnormalizedCoordinates_;
   7335       return *this;
   7336     }
   7337 
   7338     operator const VkSamplerCreateInfo&() const
   7339     {
   7340       return *reinterpret_cast<const VkSamplerCreateInfo*>(this);
   7341     }
   7342 
   7343     bool operator==( SamplerCreateInfo const& rhs ) const
   7344     {
   7345       return ( sType == rhs.sType )
   7346           && ( pNext == rhs.pNext )
   7347           && ( flags == rhs.flags )
   7348           && ( magFilter == rhs.magFilter )
   7349           && ( minFilter == rhs.minFilter )
   7350           && ( mipmapMode == rhs.mipmapMode )
   7351           && ( addressModeU == rhs.addressModeU )
   7352           && ( addressModeV == rhs.addressModeV )
   7353           && ( addressModeW == rhs.addressModeW )
   7354           && ( mipLodBias == rhs.mipLodBias )
   7355           && ( anisotropyEnable == rhs.anisotropyEnable )
   7356           && ( maxAnisotropy == rhs.maxAnisotropy )
   7357           && ( compareEnable == rhs.compareEnable )
   7358           && ( compareOp == rhs.compareOp )
   7359           && ( minLod == rhs.minLod )
   7360           && ( maxLod == rhs.maxLod )
   7361           && ( borderColor == rhs.borderColor )
   7362           && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
   7363     }
   7364 
   7365     bool operator!=( SamplerCreateInfo const& rhs ) const
   7366     {
   7367       return !operator==( rhs );
   7368     }
   7369 
   7370   private:
   7371     StructureType sType;
   7372 
   7373   public:
   7374     const void* pNext;
   7375     SamplerCreateFlags flags;
   7376     Filter magFilter;
   7377     Filter minFilter;
   7378     SamplerMipmapMode mipmapMode;
   7379     SamplerAddressMode addressModeU;
   7380     SamplerAddressMode addressModeV;
   7381     SamplerAddressMode addressModeW;
   7382     float mipLodBias;
   7383     Bool32 anisotropyEnable;
   7384     float maxAnisotropy;
   7385     Bool32 compareEnable;
   7386     CompareOp compareOp;
   7387     float minLod;
   7388     float maxLod;
   7389     BorderColor borderColor;
   7390     Bool32 unnormalizedCoordinates;
   7391   };
   7392   static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
   7393 
   7394   struct CommandBufferAllocateInfo
   7395   {
   7396     CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), CommandBufferLevel level_ = CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 )
   7397       : sType( StructureType::eCommandBufferAllocateInfo )
   7398       , pNext( nullptr )
   7399       , commandPool( commandPool_ )
   7400       , level( level_ )
   7401       , commandBufferCount( commandBufferCount_ )
   7402     {
   7403     }
   7404 
   7405     CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
   7406     {
   7407       memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) );
   7408     }
   7409 
   7410     CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
   7411     {
   7412       memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) );
   7413       return *this;
   7414     }
   7415 
   7416     CommandBufferAllocateInfo& setSType( StructureType sType_ )
   7417     {
   7418       sType = sType_;
   7419       return *this;
   7420     }
   7421 
   7422     CommandBufferAllocateInfo& setPNext( const void* pNext_ )
   7423     {
   7424       pNext = pNext_;
   7425       return *this;
   7426     }
   7427 
   7428     CommandBufferAllocateInfo& setCommandPool( CommandPool commandPool_ )
   7429     {
   7430       commandPool = commandPool_;
   7431       return *this;
   7432     }
   7433 
   7434     CommandBufferAllocateInfo& setLevel( CommandBufferLevel level_ )
   7435     {
   7436       level = level_;
   7437       return *this;
   7438     }
   7439 
   7440     CommandBufferAllocateInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
   7441     {
   7442       commandBufferCount = commandBufferCount_;
   7443       return *this;
   7444     }
   7445 
   7446     operator const VkCommandBufferAllocateInfo&() const
   7447     {
   7448       return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this);
   7449     }
   7450 
   7451     bool operator==( CommandBufferAllocateInfo const& rhs ) const
   7452     {
   7453       return ( sType == rhs.sType )
   7454           && ( pNext == rhs.pNext )
   7455           && ( commandPool == rhs.commandPool )
   7456           && ( level == rhs.level )
   7457           && ( commandBufferCount == rhs.commandBufferCount );
   7458     }
   7459 
   7460     bool operator!=( CommandBufferAllocateInfo const& rhs ) const
   7461     {
   7462       return !operator==( rhs );
   7463     }
   7464 
   7465   private:
   7466     StructureType sType;
   7467 
   7468   public:
   7469     const void* pNext;
   7470     CommandPool commandPool;
   7471     CommandBufferLevel level;
   7472     uint32_t commandBufferCount;
   7473   };
   7474   static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
   7475 
   7476   struct RenderPassBeginInfo
   7477   {
   7478     RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), Framebuffer framebuffer_ = Framebuffer(), Rect2D renderArea_ = Rect2D(), uint32_t clearValueCount_ = 0, const ClearValue* pClearValues_ = nullptr )
   7479       : sType( StructureType::eRenderPassBeginInfo )
   7480       , pNext( nullptr )
   7481       , renderPass( renderPass_ )
   7482       , framebuffer( framebuffer_ )
   7483       , renderArea( renderArea_ )
   7484       , clearValueCount( clearValueCount_ )
   7485       , pClearValues( pClearValues_ )
   7486     {
   7487     }
   7488 
   7489     RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
   7490     {
   7491       memcpy( this, &rhs, sizeof(RenderPassBeginInfo) );
   7492     }
   7493 
   7494     RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
   7495     {
   7496       memcpy( this, &rhs, sizeof(RenderPassBeginInfo) );
   7497       return *this;
   7498     }
   7499 
   7500     RenderPassBeginInfo& setSType( StructureType sType_ )
   7501     {
   7502       sType = sType_;
   7503       return *this;
   7504     }
   7505 
   7506     RenderPassBeginInfo& setPNext( const void* pNext_ )
   7507     {
   7508       pNext = pNext_;
   7509       return *this;
   7510     }
   7511 
   7512     RenderPassBeginInfo& setRenderPass( RenderPass renderPass_ )
   7513     {
   7514       renderPass = renderPass_;
   7515       return *this;
   7516     }
   7517 
   7518     RenderPassBeginInfo& setFramebuffer( Framebuffer framebuffer_ )
   7519     {
   7520       framebuffer = framebuffer_;
   7521       return *this;
   7522     }
   7523 
   7524     RenderPassBeginInfo& setRenderArea( Rect2D renderArea_ )
   7525     {
   7526       renderArea = renderArea_;
   7527       return *this;
   7528     }
   7529 
   7530     RenderPassBeginInfo& setClearValueCount( uint32_t clearValueCount_ )
   7531     {
   7532       clearValueCount = clearValueCount_;
   7533       return *this;
   7534     }
   7535 
   7536     RenderPassBeginInfo& setPClearValues( const ClearValue* pClearValues_ )
   7537     {
   7538       pClearValues = pClearValues_;
   7539       return *this;
   7540     }
   7541 
   7542     operator const VkRenderPassBeginInfo&() const
   7543     {
   7544       return *reinterpret_cast<const VkRenderPassBeginInfo*>(this);
   7545     }
   7546 
   7547     bool operator==( RenderPassBeginInfo const& rhs ) const
   7548     {
   7549       return ( sType == rhs.sType )
   7550           && ( pNext == rhs.pNext )
   7551           && ( renderPass == rhs.renderPass )
   7552           && ( framebuffer == rhs.framebuffer )
   7553           && ( renderArea == rhs.renderArea )
   7554           && ( clearValueCount == rhs.clearValueCount )
   7555           && ( pClearValues == rhs.pClearValues );
   7556     }
   7557 
   7558     bool operator!=( RenderPassBeginInfo const& rhs ) const
   7559     {
   7560       return !operator==( rhs );
   7561     }
   7562 
   7563   private:
   7564     StructureType sType;
   7565 
   7566   public:
   7567     const void* pNext;
   7568     RenderPass renderPass;
   7569     Framebuffer framebuffer;
   7570     Rect2D renderArea;
   7571     uint32_t clearValueCount;
   7572     const ClearValue* pClearValues;
   7573   };
   7574   static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
   7575 
   7576   struct EventCreateInfo
   7577   {
   7578     EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
   7579       : sType( StructureType::eEventCreateInfo )
   7580       , pNext( nullptr )
   7581       , flags( flags_ )
   7582     {
   7583     }
   7584 
   7585     EventCreateInfo( VkEventCreateInfo const & rhs )
   7586     {
   7587       memcpy( this, &rhs, sizeof(EventCreateInfo) );
   7588     }
   7589 
   7590     EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
   7591     {
   7592       memcpy( this, &rhs, sizeof(EventCreateInfo) );
   7593       return *this;
   7594     }
   7595 
   7596     EventCreateInfo& setSType( StructureType sType_ )
   7597     {
   7598       sType = sType_;
   7599       return *this;
   7600     }
   7601 
   7602     EventCreateInfo& setPNext( const void* pNext_ )
   7603     {
   7604       pNext = pNext_;
   7605       return *this;
   7606     }
   7607 
   7608     EventCreateInfo& setFlags( EventCreateFlags flags_ )
   7609     {
   7610       flags = flags_;
   7611       return *this;
   7612     }
   7613 
   7614     operator const VkEventCreateInfo&() const
   7615     {
   7616       return *reinterpret_cast<const VkEventCreateInfo*>(this);
   7617     }
   7618 
   7619     bool operator==( EventCreateInfo const& rhs ) const
   7620     {
   7621       return ( sType == rhs.sType )
   7622           && ( pNext == rhs.pNext )
   7623           && ( flags == rhs.flags );
   7624     }
   7625 
   7626     bool operator!=( EventCreateInfo const& rhs ) const
   7627     {
   7628       return !operator==( rhs );
   7629     }
   7630 
   7631   private:
   7632     StructureType sType;
   7633 
   7634   public:
   7635     const void* pNext;
   7636     EventCreateFlags flags;
   7637   };
   7638   static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
   7639 
   7640   struct SemaphoreCreateInfo
   7641   {
   7642     SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
   7643       : sType( StructureType::eSemaphoreCreateInfo )
   7644       , pNext( nullptr )
   7645       , flags( flags_ )
   7646     {
   7647     }
   7648 
   7649     SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
   7650     {
   7651       memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) );
   7652     }
   7653 
   7654     SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
   7655     {
   7656       memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) );
   7657       return *this;
   7658     }
   7659 
   7660     SemaphoreCreateInfo& setSType( StructureType sType_ )
   7661     {
   7662       sType = sType_;
   7663       return *this;
   7664     }
   7665 
   7666     SemaphoreCreateInfo& setPNext( const void* pNext_ )
   7667     {
   7668       pNext = pNext_;
   7669       return *this;
   7670     }
   7671 
   7672     SemaphoreCreateInfo& setFlags( SemaphoreCreateFlags flags_ )
   7673     {
   7674       flags = flags_;
   7675       return *this;
   7676     }
   7677 
   7678     operator const VkSemaphoreCreateInfo&() const
   7679     {
   7680       return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this);
   7681     }
   7682 
   7683     bool operator==( SemaphoreCreateInfo const& rhs ) const
   7684     {
   7685       return ( sType == rhs.sType )
   7686           && ( pNext == rhs.pNext )
   7687           && ( flags == rhs.flags );
   7688     }
   7689 
   7690     bool operator!=( SemaphoreCreateInfo const& rhs ) const
   7691     {
   7692       return !operator==( rhs );
   7693     }
   7694 
   7695   private:
   7696     StructureType sType;
   7697 
   7698   public:
   7699     const void* pNext;
   7700     SemaphoreCreateFlags flags;
   7701   };
   7702   static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
   7703 
   7704   struct FramebufferCreateInfo
   7705   {
   7706     FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), RenderPass renderPass_ = RenderPass(), uint32_t attachmentCount_ = 0, const ImageView* pAttachments_ = nullptr, uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 )
   7707       : sType( StructureType::eFramebufferCreateInfo )
   7708       , pNext( nullptr )
   7709       , flags( flags_ )
   7710       , renderPass( renderPass_ )
   7711       , attachmentCount( attachmentCount_ )
   7712       , pAttachments( pAttachments_ )
   7713       , width( width_ )
   7714       , height( height_ )
   7715       , layers( layers_ )
   7716     {
   7717     }
   7718 
   7719     FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
   7720     {
   7721       memcpy( this, &rhs, sizeof(FramebufferCreateInfo) );
   7722     }
   7723 
   7724     FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
   7725     {
   7726       memcpy( this, &rhs, sizeof(FramebufferCreateInfo) );
   7727       return *this;
   7728     }
   7729 
   7730     FramebufferCreateInfo& setSType( StructureType sType_ )
   7731     {
   7732       sType = sType_;
   7733       return *this;
   7734     }
   7735 
   7736     FramebufferCreateInfo& setPNext( const void* pNext_ )
   7737     {
   7738       pNext = pNext_;
   7739       return *this;
   7740     }
   7741 
   7742     FramebufferCreateInfo& setFlags( FramebufferCreateFlags flags_ )
   7743     {
   7744       flags = flags_;
   7745       return *this;
   7746     }
   7747 
   7748     FramebufferCreateInfo& setRenderPass( RenderPass renderPass_ )
   7749     {
   7750       renderPass = renderPass_;
   7751       return *this;
   7752     }
   7753 
   7754     FramebufferCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
   7755     {
   7756       attachmentCount = attachmentCount_;
   7757       return *this;
   7758     }
   7759 
   7760     FramebufferCreateInfo& setPAttachments( const ImageView* pAttachments_ )
   7761     {
   7762       pAttachments = pAttachments_;
   7763       return *this;
   7764     }
   7765 
   7766     FramebufferCreateInfo& setWidth( uint32_t width_ )
   7767     {
   7768       width = width_;
   7769       return *this;
   7770     }
   7771 
   7772     FramebufferCreateInfo& setHeight( uint32_t height_ )
   7773     {
   7774       height = height_;
   7775       return *this;
   7776     }
   7777 
   7778     FramebufferCreateInfo& setLayers( uint32_t layers_ )
   7779     {
   7780       layers = layers_;
   7781       return *this;
   7782     }
   7783 
   7784     operator const VkFramebufferCreateInfo&() const
   7785     {
   7786       return *reinterpret_cast<const VkFramebufferCreateInfo*>(this);
   7787     }
   7788 
   7789     bool operator==( FramebufferCreateInfo const& rhs ) const
   7790     {
   7791       return ( sType == rhs.sType )
   7792           && ( pNext == rhs.pNext )
   7793           && ( flags == rhs.flags )
   7794           && ( renderPass == rhs.renderPass )
   7795           && ( attachmentCount == rhs.attachmentCount )
   7796           && ( pAttachments == rhs.pAttachments )
   7797           && ( width == rhs.width )
   7798           && ( height == rhs.height )
   7799           && ( layers == rhs.layers );
   7800     }
   7801 
   7802     bool operator!=( FramebufferCreateInfo const& rhs ) const
   7803     {
   7804       return !operator==( rhs );
   7805     }
   7806 
   7807   private:
   7808     StructureType sType;
   7809 
   7810   public:
   7811     const void* pNext;
   7812     FramebufferCreateFlags flags;
   7813     RenderPass renderPass;
   7814     uint32_t attachmentCount;
   7815     const ImageView* pAttachments;
   7816     uint32_t width;
   7817     uint32_t height;
   7818     uint32_t layers;
   7819   };
   7820   static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
   7821 
   7822   struct DisplayModeCreateInfoKHR
   7823   {
   7824     DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
   7825       : sType( StructureType::eDisplayModeCreateInfoKHR )
   7826       , pNext( nullptr )
   7827       , flags( flags_ )
   7828       , parameters( parameters_ )
   7829     {
   7830     }
   7831 
   7832     DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
   7833     {
   7834       memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) );
   7835     }
   7836 
   7837     DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
   7838     {
   7839       memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) );
   7840       return *this;
   7841     }
   7842 
   7843     DisplayModeCreateInfoKHR& setSType( StructureType sType_ )
   7844     {
   7845       sType = sType_;
   7846       return *this;
   7847     }
   7848 
   7849     DisplayModeCreateInfoKHR& setPNext( const void* pNext_ )
   7850     {
   7851       pNext = pNext_;
   7852       return *this;
   7853     }
   7854 
   7855     DisplayModeCreateInfoKHR& setFlags( DisplayModeCreateFlagsKHR flags_ )
   7856     {
   7857       flags = flags_;
   7858       return *this;
   7859     }
   7860 
   7861     DisplayModeCreateInfoKHR& setParameters( DisplayModeParametersKHR parameters_ )
   7862     {
   7863       parameters = parameters_;
   7864       return *this;
   7865     }
   7866 
   7867     operator const VkDisplayModeCreateInfoKHR&() const
   7868     {
   7869       return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this);
   7870     }
   7871 
   7872     bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
   7873     {
   7874       return ( sType == rhs.sType )
   7875           && ( pNext == rhs.pNext )
   7876           && ( flags == rhs.flags )
   7877           && ( parameters == rhs.parameters );
   7878     }
   7879 
   7880     bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const
   7881     {
   7882       return !operator==( rhs );
   7883     }
   7884 
   7885   private:
   7886     StructureType sType;
   7887 
   7888   public:
   7889     const void* pNext;
   7890     DisplayModeCreateFlagsKHR flags;
   7891     DisplayModeParametersKHR parameters;
   7892   };
   7893   static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
   7894 
   7895   struct DisplayPresentInfoKHR
   7896   {
   7897     DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), Rect2D dstRect_ = Rect2D(), Bool32 persistent_ = 0 )
   7898       : sType( StructureType::eDisplayPresentInfoKHR )
   7899       , pNext( nullptr )
   7900       , srcRect( srcRect_ )
   7901       , dstRect( dstRect_ )
   7902       , persistent( persistent_ )
   7903     {
   7904     }
   7905 
   7906     DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
   7907     {
   7908       memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) );
   7909     }
   7910 
   7911     DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
   7912     {
   7913       memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) );
   7914       return *this;
   7915     }
   7916 
   7917     DisplayPresentInfoKHR& setSType( StructureType sType_ )
   7918     {
   7919       sType = sType_;
   7920       return *this;
   7921     }
   7922 
   7923     DisplayPresentInfoKHR& setPNext( const void* pNext_ )
   7924     {
   7925       pNext = pNext_;
   7926       return *this;
   7927     }
   7928 
   7929     DisplayPresentInfoKHR& setSrcRect( Rect2D srcRect_ )
   7930     {
   7931       srcRect = srcRect_;
   7932       return *this;
   7933     }
   7934 
   7935     DisplayPresentInfoKHR& setDstRect( Rect2D dstRect_ )
   7936     {
   7937       dstRect = dstRect_;
   7938       return *this;
   7939     }
   7940 
   7941     DisplayPresentInfoKHR& setPersistent( Bool32 persistent_ )
   7942     {
   7943       persistent = persistent_;
   7944       return *this;
   7945     }
   7946 
   7947     operator const VkDisplayPresentInfoKHR&() const
   7948     {
   7949       return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this);
   7950     }
   7951 
   7952     bool operator==( DisplayPresentInfoKHR const& rhs ) const
   7953     {
   7954       return ( sType == rhs.sType )
   7955           && ( pNext == rhs.pNext )
   7956           && ( srcRect == rhs.srcRect )
   7957           && ( dstRect == rhs.dstRect )
   7958           && ( persistent == rhs.persistent );
   7959     }
   7960 
   7961     bool operator!=( DisplayPresentInfoKHR const& rhs ) const
   7962     {
   7963       return !operator==( rhs );
   7964     }
   7965 
   7966   private:
   7967     StructureType sType;
   7968 
   7969   public:
   7970     const void* pNext;
   7971     Rect2D srcRect;
   7972     Rect2D dstRect;
   7973     Bool32 persistent;
   7974   };
   7975   static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
   7976 
   7977 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   7978   struct AndroidSurfaceCreateInfoKHR
   7979   {
   7980     AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), ANativeWindow* window_ = nullptr )
   7981       : sType( StructureType::eAndroidSurfaceCreateInfoKHR )
   7982       , pNext( nullptr )
   7983       , flags( flags_ )
   7984       , window( window_ )
   7985     {
   7986     }
   7987 
   7988     AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
   7989     {
   7990       memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) );
   7991     }
   7992 
   7993     AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
   7994     {
   7995       memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) );
   7996       return *this;
   7997     }
   7998 
   7999     AndroidSurfaceCreateInfoKHR& setSType( StructureType sType_ )
   8000     {
   8001       sType = sType_;
   8002       return *this;
   8003     }
   8004 
   8005     AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   8006     {
   8007       pNext = pNext_;
   8008       return *this;
   8009     }
   8010 
   8011     AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
   8012     {
   8013       flags = flags_;
   8014       return *this;
   8015     }
   8016 
   8017     AndroidSurfaceCreateInfoKHR& setWindow( ANativeWindow* window_ )
   8018     {
   8019       window = window_;
   8020       return *this;
   8021     }
   8022 
   8023     operator const VkAndroidSurfaceCreateInfoKHR&() const
   8024     {
   8025       return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this);
   8026     }
   8027 
   8028     bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
   8029     {
   8030       return ( sType == rhs.sType )
   8031           && ( pNext == rhs.pNext )
   8032           && ( flags == rhs.flags )
   8033           && ( window == rhs.window );
   8034     }
   8035 
   8036     bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const
   8037     {
   8038       return !operator==( rhs );
   8039     }
   8040 
   8041   private:
   8042     StructureType sType;
   8043 
   8044   public:
   8045     const void* pNext;
   8046     AndroidSurfaceCreateFlagsKHR flags;
   8047     ANativeWindow* window;
   8048   };
   8049   static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   8050 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
   8051 
   8052 #ifdef VK_USE_PLATFORM_MIR_KHR
   8053   struct MirSurfaceCreateInfoKHR
   8054   {
   8055     MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), MirConnection* connection_ = nullptr, MirSurface* mirSurface_ = nullptr )
   8056       : sType( StructureType::eMirSurfaceCreateInfoKHR )
   8057       , pNext( nullptr )
   8058       , flags( flags_ )
   8059       , connection( connection_ )
   8060       , mirSurface( mirSurface_ )
   8061     {
   8062     }
   8063 
   8064     MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs )
   8065     {
   8066       memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) );
   8067     }
   8068 
   8069     MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs )
   8070     {
   8071       memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) );
   8072       return *this;
   8073     }
   8074 
   8075     MirSurfaceCreateInfoKHR& setSType( StructureType sType_ )
   8076     {
   8077       sType = sType_;
   8078       return *this;
   8079     }
   8080 
   8081     MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   8082     {
   8083       pNext = pNext_;
   8084       return *this;
   8085     }
   8086 
   8087     MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ )
   8088     {
   8089       flags = flags_;
   8090       return *this;
   8091     }
   8092 
   8093     MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ )
   8094     {
   8095       connection = connection_;
   8096       return *this;
   8097     }
   8098 
   8099     MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ )
   8100     {
   8101       mirSurface = mirSurface_;
   8102       return *this;
   8103     }
   8104 
   8105     operator const VkMirSurfaceCreateInfoKHR&() const
   8106     {
   8107       return *reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>(this);
   8108     }
   8109 
   8110     bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const
   8111     {
   8112       return ( sType == rhs.sType )
   8113           && ( pNext == rhs.pNext )
   8114           && ( flags == rhs.flags )
   8115           && ( connection == rhs.connection )
   8116           && ( mirSurface == rhs.mirSurface );
   8117     }
   8118 
   8119     bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const
   8120     {
   8121       return !operator==( rhs );
   8122     }
   8123 
   8124   private:
   8125     StructureType sType;
   8126 
   8127   public:
   8128     const void* pNext;
   8129     MirSurfaceCreateFlagsKHR flags;
   8130     MirConnection* connection;
   8131     MirSurface* mirSurface;
   8132   };
   8133   static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   8134 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   8135 
   8136 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   8137   struct WaylandSurfaceCreateInfoKHR
   8138   {
   8139     WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr )
   8140       : sType( StructureType::eWaylandSurfaceCreateInfoKHR )
   8141       , pNext( nullptr )
   8142       , flags( flags_ )
   8143       , display( display_ )
   8144       , surface( surface_ )
   8145     {
   8146     }
   8147 
   8148     WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
   8149     {
   8150       memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) );
   8151     }
   8152 
   8153     WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
   8154     {
   8155       memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) );
   8156       return *this;
   8157     }
   8158 
   8159     WaylandSurfaceCreateInfoKHR& setSType( StructureType sType_ )
   8160     {
   8161       sType = sType_;
   8162       return *this;
   8163     }
   8164 
   8165     WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   8166     {
   8167       pNext = pNext_;
   8168       return *this;
   8169     }
   8170 
   8171     WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
   8172     {
   8173       flags = flags_;
   8174       return *this;
   8175     }
   8176 
   8177     WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ )
   8178     {
   8179       display = display_;
   8180       return *this;
   8181     }
   8182 
   8183     WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ )
   8184     {
   8185       surface = surface_;
   8186       return *this;
   8187     }
   8188 
   8189     operator const VkWaylandSurfaceCreateInfoKHR&() const
   8190     {
   8191       return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this);
   8192     }
   8193 
   8194     bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
   8195     {
   8196       return ( sType == rhs.sType )
   8197           && ( pNext == rhs.pNext )
   8198           && ( flags == rhs.flags )
   8199           && ( display == rhs.display )
   8200           && ( surface == rhs.surface );
   8201     }
   8202 
   8203     bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const
   8204     {
   8205       return !operator==( rhs );
   8206     }
   8207 
   8208   private:
   8209     StructureType sType;
   8210 
   8211   public:
   8212     const void* pNext;
   8213     WaylandSurfaceCreateFlagsKHR flags;
   8214     struct wl_display* display;
   8215     struct wl_surface* surface;
   8216   };
   8217   static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   8218 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   8219 
   8220 #ifdef VK_USE_PLATFORM_WIN32_KHR
   8221   struct Win32SurfaceCreateInfoKHR
   8222   {
   8223     Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 )
   8224       : sType( StructureType::eWin32SurfaceCreateInfoKHR )
   8225       , pNext( nullptr )
   8226       , flags( flags_ )
   8227       , hinstance( hinstance_ )
   8228       , hwnd( hwnd_ )
   8229     {
   8230     }
   8231 
   8232     Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
   8233     {
   8234       memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) );
   8235     }
   8236 
   8237     Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
   8238     {
   8239       memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) );
   8240       return *this;
   8241     }
   8242 
   8243     Win32SurfaceCreateInfoKHR& setSType( StructureType sType_ )
   8244     {
   8245       sType = sType_;
   8246       return *this;
   8247     }
   8248 
   8249     Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   8250     {
   8251       pNext = pNext_;
   8252       return *this;
   8253     }
   8254 
   8255     Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ )
   8256     {
   8257       flags = flags_;
   8258       return *this;
   8259     }
   8260 
   8261     Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ )
   8262     {
   8263       hinstance = hinstance_;
   8264       return *this;
   8265     }
   8266 
   8267     Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ )
   8268     {
   8269       hwnd = hwnd_;
   8270       return *this;
   8271     }
   8272 
   8273     operator const VkWin32SurfaceCreateInfoKHR&() const
   8274     {
   8275       return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this);
   8276     }
   8277 
   8278     bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
   8279     {
   8280       return ( sType == rhs.sType )
   8281           && ( pNext == rhs.pNext )
   8282           && ( flags == rhs.flags )
   8283           && ( hinstance == rhs.hinstance )
   8284           && ( hwnd == rhs.hwnd );
   8285     }
   8286 
   8287     bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const
   8288     {
   8289       return !operator==( rhs );
   8290     }
   8291 
   8292   private:
   8293     StructureType sType;
   8294 
   8295   public:
   8296     const void* pNext;
   8297     Win32SurfaceCreateFlagsKHR flags;
   8298     HINSTANCE hinstance;
   8299     HWND hwnd;
   8300   };
   8301   static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   8302 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   8303 
   8304 #ifdef VK_USE_PLATFORM_XLIB_KHR
   8305   struct XlibSurfaceCreateInfoKHR
   8306   {
   8307     XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 )
   8308       : sType( StructureType::eXlibSurfaceCreateInfoKHR )
   8309       , pNext( nullptr )
   8310       , flags( flags_ )
   8311       , dpy( dpy_ )
   8312       , window( window_ )
   8313     {
   8314     }
   8315 
   8316     XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
   8317     {
   8318       memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) );
   8319     }
   8320 
   8321     XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
   8322     {
   8323       memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) );
   8324       return *this;
   8325     }
   8326 
   8327     XlibSurfaceCreateInfoKHR& setSType( StructureType sType_ )
   8328     {
   8329       sType = sType_;
   8330       return *this;
   8331     }
   8332 
   8333     XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   8334     {
   8335       pNext = pNext_;
   8336       return *this;
   8337     }
   8338 
   8339     XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ )
   8340     {
   8341       flags = flags_;
   8342       return *this;
   8343     }
   8344 
   8345     XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ )
   8346     {
   8347       dpy = dpy_;
   8348       return *this;
   8349     }
   8350 
   8351     XlibSurfaceCreateInfoKHR& setWindow( Window window_ )
   8352     {
   8353       window = window_;
   8354       return *this;
   8355     }
   8356 
   8357     operator const VkXlibSurfaceCreateInfoKHR&() const
   8358     {
   8359       return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this);
   8360     }
   8361 
   8362     bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
   8363     {
   8364       return ( sType == rhs.sType )
   8365           && ( pNext == rhs.pNext )
   8366           && ( flags == rhs.flags )
   8367           && ( dpy == rhs.dpy )
   8368           && ( window == rhs.window );
   8369     }
   8370 
   8371     bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const
   8372     {
   8373       return !operator==( rhs );
   8374     }
   8375 
   8376   private:
   8377     StructureType sType;
   8378 
   8379   public:
   8380     const void* pNext;
   8381     XlibSurfaceCreateFlagsKHR flags;
   8382     Display* dpy;
   8383     Window window;
   8384   };
   8385   static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   8386 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   8387 
   8388 #ifdef VK_USE_PLATFORM_XCB_KHR
   8389   struct XcbSurfaceCreateInfoKHR
   8390   {
   8391     XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 )
   8392       : sType( StructureType::eXcbSurfaceCreateInfoKHR )
   8393       , pNext( nullptr )
   8394       , flags( flags_ )
   8395       , connection( connection_ )
   8396       , window( window_ )
   8397     {
   8398     }
   8399 
   8400     XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
   8401     {
   8402       memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) );
   8403     }
   8404 
   8405     XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
   8406     {
   8407       memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) );
   8408       return *this;
   8409     }
   8410 
   8411     XcbSurfaceCreateInfoKHR& setSType( StructureType sType_ )
   8412     {
   8413       sType = sType_;
   8414       return *this;
   8415     }
   8416 
   8417     XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   8418     {
   8419       pNext = pNext_;
   8420       return *this;
   8421     }
   8422 
   8423     XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ )
   8424     {
   8425       flags = flags_;
   8426       return *this;
   8427     }
   8428 
   8429     XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ )
   8430     {
   8431       connection = connection_;
   8432       return *this;
   8433     }
   8434 
   8435     XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ )
   8436     {
   8437       window = window_;
   8438       return *this;
   8439     }
   8440 
   8441     operator const VkXcbSurfaceCreateInfoKHR&() const
   8442     {
   8443       return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this);
   8444     }
   8445 
   8446     bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
   8447     {
   8448       return ( sType == rhs.sType )
   8449           && ( pNext == rhs.pNext )
   8450           && ( flags == rhs.flags )
   8451           && ( connection == rhs.connection )
   8452           && ( window == rhs.window );
   8453     }
   8454 
   8455     bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const
   8456     {
   8457       return !operator==( rhs );
   8458     }
   8459 
   8460   private:
   8461     StructureType sType;
   8462 
   8463   public:
   8464     const void* pNext;
   8465     XcbSurfaceCreateFlagsKHR flags;
   8466     xcb_connection_t* connection;
   8467     xcb_window_t window;
   8468   };
   8469   static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   8470 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   8471 
   8472   struct DebugMarkerMarkerInfoEXT
   8473   {
   8474     DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
   8475       : sType( StructureType::eDebugMarkerMarkerInfoEXT )
   8476       , pNext( nullptr )
   8477       , pMarkerName( pMarkerName_ )
   8478     {
   8479       memcpy( &color, color_.data(), 4 * sizeof( float ) );
   8480     }
   8481 
   8482     DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
   8483     {
   8484       memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) );
   8485     }
   8486 
   8487     DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
   8488     {
   8489       memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) );
   8490       return *this;
   8491     }
   8492 
   8493     DebugMarkerMarkerInfoEXT& setSType( StructureType sType_ )
   8494     {
   8495       sType = sType_;
   8496       return *this;
   8497     }
   8498 
   8499     DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ )
   8500     {
   8501       pNext = pNext_;
   8502       return *this;
   8503     }
   8504 
   8505     DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ )
   8506     {
   8507       pMarkerName = pMarkerName_;
   8508       return *this;
   8509     }
   8510 
   8511     DebugMarkerMarkerInfoEXT& setColor( std::array<float,4> color_ )
   8512     {
   8513       memcpy( &color, color_.data(), 4 * sizeof( float ) );
   8514       return *this;
   8515     }
   8516 
   8517     operator const VkDebugMarkerMarkerInfoEXT&() const
   8518     {
   8519       return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this);
   8520     }
   8521 
   8522     bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
   8523     {
   8524       return ( sType == rhs.sType )
   8525           && ( pNext == rhs.pNext )
   8526           && ( pMarkerName == rhs.pMarkerName )
   8527           && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
   8528     }
   8529 
   8530     bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const
   8531     {
   8532       return !operator==( rhs );
   8533     }
   8534 
   8535   private:
   8536     StructureType sType;
   8537 
   8538   public:
   8539     const void* pNext;
   8540     const char* pMarkerName;
   8541     float color[4];
   8542   };
   8543   static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
   8544 
   8545   struct DedicatedAllocationImageCreateInfoNV
   8546   {
   8547     DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
   8548       : sType( StructureType::eDedicatedAllocationImageCreateInfoNV )
   8549       , pNext( nullptr )
   8550       , dedicatedAllocation( dedicatedAllocation_ )
   8551     {
   8552     }
   8553 
   8554     DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
   8555     {
   8556       memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) );
   8557     }
   8558 
   8559     DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
   8560     {
   8561       memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) );
   8562       return *this;
   8563     }
   8564 
   8565     DedicatedAllocationImageCreateInfoNV& setSType( StructureType sType_ )
   8566     {
   8567       sType = sType_;
   8568       return *this;
   8569     }
   8570 
   8571     DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ )
   8572     {
   8573       pNext = pNext_;
   8574       return *this;
   8575     }
   8576 
   8577     DedicatedAllocationImageCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ )
   8578     {
   8579       dedicatedAllocation = dedicatedAllocation_;
   8580       return *this;
   8581     }
   8582 
   8583     operator const VkDedicatedAllocationImageCreateInfoNV&() const
   8584     {
   8585       return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this);
   8586     }
   8587 
   8588     bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const
   8589     {
   8590       return ( sType == rhs.sType )
   8591           && ( pNext == rhs.pNext )
   8592           && ( dedicatedAllocation == rhs.dedicatedAllocation );
   8593     }
   8594 
   8595     bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const
   8596     {
   8597       return !operator==( rhs );
   8598     }
   8599 
   8600   private:
   8601     StructureType sType;
   8602 
   8603   public:
   8604     const void* pNext;
   8605     Bool32 dedicatedAllocation;
   8606   };
   8607   static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
   8608 
   8609   struct DedicatedAllocationBufferCreateInfoNV
   8610   {
   8611     DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
   8612       : sType( StructureType::eDedicatedAllocationBufferCreateInfoNV )
   8613       , pNext( nullptr )
   8614       , dedicatedAllocation( dedicatedAllocation_ )
   8615     {
   8616     }
   8617 
   8618     DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
   8619     {
   8620       memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) );
   8621     }
   8622 
   8623     DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
   8624     {
   8625       memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) );
   8626       return *this;
   8627     }
   8628 
   8629     DedicatedAllocationBufferCreateInfoNV& setSType( StructureType sType_ )
   8630     {
   8631       sType = sType_;
   8632       return *this;
   8633     }
   8634 
   8635     DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ )
   8636     {
   8637       pNext = pNext_;
   8638       return *this;
   8639     }
   8640 
   8641     DedicatedAllocationBufferCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ )
   8642     {
   8643       dedicatedAllocation = dedicatedAllocation_;
   8644       return *this;
   8645     }
   8646 
   8647     operator const VkDedicatedAllocationBufferCreateInfoNV&() const
   8648     {
   8649       return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this);
   8650     }
   8651 
   8652     bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
   8653     {
   8654       return ( sType == rhs.sType )
   8655           && ( pNext == rhs.pNext )
   8656           && ( dedicatedAllocation == rhs.dedicatedAllocation );
   8657     }
   8658 
   8659     bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
   8660     {
   8661       return !operator==( rhs );
   8662     }
   8663 
   8664   private:
   8665     StructureType sType;
   8666 
   8667   public:
   8668     const void* pNext;
   8669     Bool32 dedicatedAllocation;
   8670   };
   8671   static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
   8672 
   8673   struct DedicatedAllocationMemoryAllocateInfoNV
   8674   {
   8675     DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), Buffer buffer_ = Buffer() )
   8676       : sType( StructureType::eDedicatedAllocationMemoryAllocateInfoNV )
   8677       , pNext( nullptr )
   8678       , image( image_ )
   8679       , buffer( buffer_ )
   8680     {
   8681     }
   8682 
   8683     DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
   8684     {
   8685       memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) );
   8686     }
   8687 
   8688     DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
   8689     {
   8690       memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) );
   8691       return *this;
   8692     }
   8693 
   8694     DedicatedAllocationMemoryAllocateInfoNV& setSType( StructureType sType_ )
   8695     {
   8696       sType = sType_;
   8697       return *this;
   8698     }
   8699 
   8700     DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ )
   8701     {
   8702       pNext = pNext_;
   8703       return *this;
   8704     }
   8705 
   8706     DedicatedAllocationMemoryAllocateInfoNV& setImage( Image image_ )
   8707     {
   8708       image = image_;
   8709       return *this;
   8710     }
   8711 
   8712     DedicatedAllocationMemoryAllocateInfoNV& setBuffer( Buffer buffer_ )
   8713     {
   8714       buffer = buffer_;
   8715       return *this;
   8716     }
   8717 
   8718     operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const
   8719     {
   8720       return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
   8721     }
   8722 
   8723     bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
   8724     {
   8725       return ( sType == rhs.sType )
   8726           && ( pNext == rhs.pNext )
   8727           && ( image == rhs.image )
   8728           && ( buffer == rhs.buffer );
   8729     }
   8730 
   8731     bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
   8732     {
   8733       return !operator==( rhs );
   8734     }
   8735 
   8736   private:
   8737     StructureType sType;
   8738 
   8739   public:
   8740     const void* pNext;
   8741     Image image;
   8742     Buffer buffer;
   8743   };
   8744   static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   8745 
   8746 #ifdef VK_USE_PLATFORM_WIN32_KHR
   8747   struct ExportMemoryWin32HandleInfoNV
   8748   {
   8749     ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 )
   8750       : sType( StructureType::eExportMemoryWin32HandleInfoNV )
   8751       , pNext( nullptr )
   8752       , pAttributes( pAttributes_ )
   8753       , dwAccess( dwAccess_ )
   8754     {
   8755     }
   8756 
   8757     ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
   8758     {
   8759       memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) );
   8760     }
   8761 
   8762     ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
   8763     {
   8764       memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) );
   8765       return *this;
   8766     }
   8767 
   8768     ExportMemoryWin32HandleInfoNV& setSType( StructureType sType_ )
   8769     {
   8770       sType = sType_;
   8771       return *this;
   8772     }
   8773 
   8774     ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
   8775     {
   8776       pNext = pNext_;
   8777       return *this;
   8778     }
   8779 
   8780     ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
   8781     {
   8782       pAttributes = pAttributes_;
   8783       return *this;
   8784     }
   8785 
   8786     ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ )
   8787     {
   8788       dwAccess = dwAccess_;
   8789       return *this;
   8790     }
   8791 
   8792     operator const VkExportMemoryWin32HandleInfoNV&() const
   8793     {
   8794       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
   8795     }
   8796 
   8797     bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
   8798     {
   8799       return ( sType == rhs.sType )
   8800           && ( pNext == rhs.pNext )
   8801           && ( pAttributes == rhs.pAttributes )
   8802           && ( dwAccess == rhs.dwAccess );
   8803     }
   8804 
   8805     bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const
   8806     {
   8807       return !operator==( rhs );
   8808     }
   8809 
   8810   private:
   8811     StructureType sType;
   8812 
   8813   public:
   8814     const void* pNext;
   8815     const SECURITY_ATTRIBUTES* pAttributes;
   8816     DWORD dwAccess;
   8817   };
   8818   static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   8819 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   8820 
   8821 #ifdef VK_USE_PLATFORM_WIN32_KHR
   8822   struct Win32KeyedMutexAcquireReleaseInfoNV
   8823   {
   8824     Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
   8825       : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoNV )
   8826       , pNext( nullptr )
   8827       , acquireCount( acquireCount_ )
   8828       , pAcquireSyncs( pAcquireSyncs_ )
   8829       , pAcquireKeys( pAcquireKeys_ )
   8830       , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
   8831       , releaseCount( releaseCount_ )
   8832       , pReleaseSyncs( pReleaseSyncs_ )
   8833       , pReleaseKeys( pReleaseKeys_ )
   8834     {
   8835     }
   8836 
   8837     Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
   8838     {
   8839       memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) );
   8840     }
   8841 
   8842     Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
   8843     {
   8844       memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) );
   8845       return *this;
   8846     }
   8847 
   8848     Win32KeyedMutexAcquireReleaseInfoNV& setSType( StructureType sType_ )
   8849     {
   8850       sType = sType_;
   8851       return *this;
   8852     }
   8853 
   8854     Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ )
   8855     {
   8856       pNext = pNext_;
   8857       return *this;
   8858     }
   8859 
   8860     Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ )
   8861     {
   8862       acquireCount = acquireCount_;
   8863       return *this;
   8864     }
   8865 
   8866     Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
   8867     {
   8868       pAcquireSyncs = pAcquireSyncs_;
   8869       return *this;
   8870     }
   8871 
   8872     Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
   8873     {
   8874       pAcquireKeys = pAcquireKeys_;
   8875       return *this;
   8876     }
   8877 
   8878     Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ )
   8879     {
   8880       pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_;
   8881       return *this;
   8882     }
   8883 
   8884     Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ )
   8885     {
   8886       releaseCount = releaseCount_;
   8887       return *this;
   8888     }
   8889 
   8890     Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
   8891     {
   8892       pReleaseSyncs = pReleaseSyncs_;
   8893       return *this;
   8894     }
   8895 
   8896     Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
   8897     {
   8898       pReleaseKeys = pReleaseKeys_;
   8899       return *this;
   8900     }
   8901 
   8902     operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const
   8903     {
   8904       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
   8905     }
   8906 
   8907     bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
   8908     {
   8909       return ( sType == rhs.sType )
   8910           && ( pNext == rhs.pNext )
   8911           && ( acquireCount == rhs.acquireCount )
   8912           && ( pAcquireSyncs == rhs.pAcquireSyncs )
   8913           && ( pAcquireKeys == rhs.pAcquireKeys )
   8914           && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds )
   8915           && ( releaseCount == rhs.releaseCount )
   8916           && ( pReleaseSyncs == rhs.pReleaseSyncs )
   8917           && ( pReleaseKeys == rhs.pReleaseKeys );
   8918     }
   8919 
   8920     bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
   8921     {
   8922       return !operator==( rhs );
   8923     }
   8924 
   8925   private:
   8926     StructureType sType;
   8927 
   8928   public:
   8929     const void* pNext;
   8930     uint32_t acquireCount;
   8931     const DeviceMemory* pAcquireSyncs;
   8932     const uint64_t* pAcquireKeys;
   8933     const uint32_t* pAcquireTimeoutMilliseconds;
   8934     uint32_t releaseCount;
   8935     const DeviceMemory* pReleaseSyncs;
   8936     const uint64_t* pReleaseKeys;
   8937   };
   8938   static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
   8939 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   8940 
   8941   enum class SubpassContents
   8942   {
   8943     eInline = VK_SUBPASS_CONTENTS_INLINE,
   8944     eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
   8945   };
   8946 
   8947   struct PresentInfoKHR
   8948   {
   8949     ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 )
   8950       : sType( StructureType::eExportMemoryWin32HandleInfoNV )
   8951       , pNext( nullptr )
   8952       , pAttributes( pAttributes_ )
   8953       , dwAccess( dwAccess_ )
   8954     {
   8955     }
   8956 
   8957     ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
   8958     {
   8959       memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) );
   8960     }
   8961 
   8962     ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
   8963     {
   8964       memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) );
   8965       return *this;
   8966     }
   8967 
   8968     ExportMemoryWin32HandleInfoNV& setSType( StructureType sType_ )
   8969     {
   8970       sType = sType_;
   8971       return *this;
   8972     }
   8973 
   8974     ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
   8975     {
   8976       pNext = pNext_;
   8977       return *this;
   8978     }
   8979 
   8980     ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
   8981     {
   8982       pAttributes = pAttributes_;
   8983       return *this;
   8984     }
   8985 
   8986     ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ )
   8987     {
   8988       dwAccess = dwAccess_;
   8989       return *this;
   8990     }
   8991 
   8992     operator const VkExportMemoryWin32HandleInfoNV&() const
   8993     {
   8994       return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
   8995     }
   8996 
   8997     bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
   8998     {
   8999       return ( sType == rhs.sType )
   9000           && ( pNext == rhs.pNext )
   9001           && ( pAttributes == rhs.pAttributes )
   9002           && ( dwAccess == rhs.dwAccess );
   9003     }
   9004 
   9005     bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const
   9006     {
   9007       return !operator==( rhs );
   9008     }
   9009 
   9010   private:
   9011     StructureType sType;
   9012 
   9013   public:
   9014     const void* pNext;
   9015     const SECURITY_ATTRIBUTES* pAttributes;
   9016     DWORD dwAccess;
   9017   };
   9018   static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   9019 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   9020 
   9021 #ifdef VK_USE_PLATFORM_WIN32_KHR
   9022   struct Win32KeyedMutexAcquireReleaseInfoNV
   9023   {
   9024     Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
   9025       : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoNV )
   9026       , pNext( nullptr )
   9027       , acquireCount( acquireCount_ )
   9028       , pAcquireSyncs( pAcquireSyncs_ )
   9029       , pAcquireKeys( pAcquireKeys_ )
   9030       , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
   9031       , releaseCount( releaseCount_ )
   9032       , pReleaseSyncs( pReleaseSyncs_ )
   9033       , pReleaseKeys( pReleaseKeys_ )
   9034     {
   9035     }
   9036 
   9037     Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
   9038     {
   9039       memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) );
   9040     }
   9041 
   9042     Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
   9043     {
   9044       memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) );
   9045       return *this;
   9046     }
   9047 
   9048     Win32KeyedMutexAcquireReleaseInfoNV& setSType( StructureType sType_ )
   9049     {
   9050       sType = sType_;
   9051       return *this;
   9052     }
   9053 
   9054     Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ )
   9055     {
   9056       pNext = pNext_;
   9057       return *this;
   9058     }
   9059 
   9060     Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ )
   9061     {
   9062       acquireCount = acquireCount_;
   9063       return *this;
   9064     }
   9065 
   9066     Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
   9067     {
   9068       pAcquireSyncs = pAcquireSyncs_;
   9069       return *this;
   9070     }
   9071 
   9072     Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
   9073     {
   9074       pAcquireKeys = pAcquireKeys_;
   9075       return *this;
   9076     }
   9077 
   9078     Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ )
   9079     {
   9080       pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_;
   9081       return *this;
   9082     }
   9083 
   9084     Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ )
   9085     {
   9086       releaseCount = releaseCount_;
   9087       return *this;
   9088     }
   9089 
   9090     Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
   9091     {
   9092       pReleaseSyncs = pReleaseSyncs_;
   9093       return *this;
   9094     }
   9095 
   9096     Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
   9097     {
   9098       pReleaseKeys = pReleaseKeys_;
   9099       return *this;
   9100     }
   9101 
   9102     operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const
   9103     {
   9104       return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
   9105     }
   9106 
   9107     bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
   9108     {
   9109       return ( sType == rhs.sType )
   9110           && ( pNext == rhs.pNext )
   9111           && ( acquireCount == rhs.acquireCount )
   9112           && ( pAcquireSyncs == rhs.pAcquireSyncs )
   9113           && ( pAcquireKeys == rhs.pAcquireKeys )
   9114           && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds )
   9115           && ( releaseCount == rhs.releaseCount )
   9116           && ( pReleaseSyncs == rhs.pReleaseSyncs )
   9117           && ( pReleaseKeys == rhs.pReleaseKeys );
   9118     }
   9119 
   9120     bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
   9121     {
   9122       return !operator==( rhs );
   9123     }
   9124 
   9125   private:
   9126     StructureType sType;
   9127 
   9128   public:
   9129     const void* pNext;
   9130     uint32_t acquireCount;
   9131     const DeviceMemory* pAcquireSyncs;
   9132     const uint64_t* pAcquireKeys;
   9133     const uint32_t* pAcquireTimeoutMilliseconds;
   9134     uint32_t releaseCount;
   9135     const DeviceMemory* pReleaseSyncs;
   9136     const uint64_t* pReleaseKeys;
   9137   };
   9138   static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
   9139 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   9140 
   9141   enum class SubpassContents
   9142   {
   9143     eInline = VK_SUBPASS_CONTENTS_INLINE,
   9144     eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
   9145   };
   9146 
   9147   struct PresentInfoKHR
   9148   {
   9149     PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr )
   9150       : sType( StructureType::ePresentInfoKHR )
   9151       , pNext( nullptr )
   9152       , waitSemaphoreCount( waitSemaphoreCount_ )
   9153       , pWaitSemaphores( pWaitSemaphores_ )
   9154       , swapchainCount( swapchainCount_ )
   9155       , pSwapchains( pSwapchains_ )
   9156       , pImageIndices( pImageIndices_ )
   9157       , pResults( pResults_ )
   9158     {
   9159     }
   9160 
   9161     PresentInfoKHR( VkPresentInfoKHR const & rhs )
   9162     {
   9163       memcpy( this, &rhs, sizeof(PresentInfoKHR) );
   9164     }
   9165 
   9166     PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
   9167     {
   9168       memcpy( this, &rhs, sizeof(PresentInfoKHR) );
   9169       return *this;
   9170     }
   9171 
   9172     PresentInfoKHR& setSType( StructureType sType_ )
   9173     {
   9174       sType = sType_;
   9175       return *this;
   9176     }
   9177 
   9178     PresentInfoKHR& setPNext( const void* pNext_ )
   9179     {
   9180       pNext = pNext_;
   9181       return *this;
   9182     }
   9183 
   9184     PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
   9185     {
   9186       waitSemaphoreCount = waitSemaphoreCount_;
   9187       return *this;
   9188     }
   9189 
   9190     PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
   9191     {
   9192       pWaitSemaphores = pWaitSemaphores_;
   9193       return *this;
   9194     }
   9195 
   9196     PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
   9197     {
   9198       swapchainCount = swapchainCount_;
   9199       return *this;
   9200     }
   9201 
   9202     PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
   9203     {
   9204       pSwapchains = pSwapchains_;
   9205       return *this;
   9206     }
   9207 
   9208     PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
   9209     {
   9210       pImageIndices = pImageIndices_;
   9211       return *this;
   9212     }
   9213 
   9214     PresentInfoKHR& setPResults( Result* pResults_ )
   9215     {
   9216       pResults = pResults_;
   9217       return *this;
   9218     }
   9219 
   9220     operator const VkPresentInfoKHR&() const
   9221     {
   9222       return *reinterpret_cast<const VkPresentInfoKHR*>(this);
   9223     }
   9224 
   9225     bool operator==( PresentInfoKHR const& rhs ) const
   9226     {
   9227       return ( sType == rhs.sType )
   9228           && ( pNext == rhs.pNext )
   9229           && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
   9230           && ( pWaitSemaphores == rhs.pWaitSemaphores )
   9231           && ( swapchainCount == rhs.swapchainCount )
   9232           && ( pSwapchains == rhs.pSwapchains )
   9233           && ( pImageIndices == rhs.pImageIndices )
   9234           && ( pResults == rhs.pResults );
   9235     }
   9236 
   9237     bool operator!=( PresentInfoKHR const& rhs ) const
   9238     {
   9239       return !operator==( rhs );
   9240     }
   9241 
   9242   private:
   9243     StructureType sType;
   9244 
   9245   public:
   9246     const void* pNext;
   9247     uint32_t waitSemaphoreCount;
   9248     const Semaphore* pWaitSemaphores;
   9249     uint32_t swapchainCount;
   9250     const SwapchainKHR* pSwapchains;
   9251     const uint32_t* pImageIndices;
   9252     Result* pResults;
   9253   };
   9254   static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
   9255 
   9256   enum class DynamicState
   9257   {
   9258     eViewport = VK_DYNAMIC_STATE_VIEWPORT,
   9259     eScissor = VK_DYNAMIC_STATE_SCISSOR,
   9260     eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
   9261     eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
   9262     eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
   9263     eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
   9264     eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
   9265     eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
   9266     eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE
   9267   };
   9268 
   9269   struct PipelineDynamicStateCreateInfo
   9270   {
   9271     PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr )
   9272       : sType( StructureType::ePipelineDynamicStateCreateInfo )
   9273       , pNext( nullptr )
   9274       , flags( flags_ )
   9275       , dynamicStateCount( dynamicStateCount_ )
   9276       , pDynamicStates( pDynamicStates_ )
   9277     {
   9278     }
   9279 
   9280     PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
   9281     {
   9282       memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
   9283     }
   9284 
   9285     PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
   9286     {
   9287       memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
   9288       return *this;
   9289     }
   9290 
   9291     PipelineDynamicStateCreateInfo& setSType( StructureType sType_ )
   9292     {
   9293       sType = sType_;
   9294       return *this;
   9295     }
   9296 
   9297     PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
   9298     {
   9299       pNext = pNext_;
   9300       return *this;
   9301     }
   9302 
   9303     PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
   9304     {
   9305       flags = flags_;
   9306       return *this;
   9307     }
   9308 
   9309     PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
   9310     {
   9311       dynamicStateCount = dynamicStateCount_;
   9312       return *this;
   9313     }
   9314 
   9315     PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
   9316     {
   9317       pDynamicStates = pDynamicStates_;
   9318       return *this;
   9319     }
   9320 
   9321     operator const VkPipelineDynamicStateCreateInfo&() const
   9322     {
   9323       return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
   9324     }
   9325 
   9326     bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
   9327     {
   9328       return ( sType == rhs.sType )
   9329           && ( pNext == rhs.pNext )
   9330           && ( flags == rhs.flags )
   9331           && ( dynamicStateCount == rhs.dynamicStateCount )
   9332           && ( pDynamicStates == rhs.pDynamicStates );
   9333     }
   9334 
   9335     bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
   9336     {
   9337       return !operator==( rhs );
   9338     }
   9339 
   9340   private:
   9341     StructureType sType;
   9342 
   9343   public:
   9344     const void* pNext;
   9345     PipelineDynamicStateCreateFlags flags;
   9346     uint32_t dynamicStateCount;
   9347     const DynamicState* pDynamicStates;
   9348   };
   9349   static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
   9350 
   9351   enum class QueueFlagBits
   9352   {
   9353     eGraphics = VK_QUEUE_GRAPHICS_BIT,
   9354     eCompute = VK_QUEUE_COMPUTE_BIT,
   9355     eTransfer = VK_QUEUE_TRANSFER_BIT,
   9356     eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT
   9357   };
   9358 
   9359   using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
   9360 
   9361   inline QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
   9362   {
   9363     return QueueFlags( bit0 ) | bit1;
   9364   }
   9365 
   9366   struct QueueFamilyProperties
   9367   {
   9368     operator const VkQueueFamilyProperties&() const
   9369     {
   9370       return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
   9371     }
   9372 
   9373     bool operator==( QueueFamilyProperties const& rhs ) const
   9374     {
   9375       return ( queueFlags == rhs.queueFlags )
   9376           && ( queueCount == rhs.queueCount )
   9377           && ( timestampValidBits == rhs.timestampValidBits )
   9378           && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
   9379     }
   9380 
   9381     bool operator!=( QueueFamilyProperties const& rhs ) const
   9382     {
   9383       return !operator==( rhs );
   9384     }
   9385 
   9386     QueueFlags queueFlags;
   9387     uint32_t queueCount;
   9388     uint32_t timestampValidBits;
   9389     Extent3D minImageTransferGranularity;
   9390   };
   9391   static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
   9392 
   9393   enum class MemoryPropertyFlagBits
   9394   {
   9395     eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
   9396     eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
   9397     eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
   9398     eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
   9399     eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
   9400   };
   9401 
   9402   using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
   9403 
   9404   inline MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
   9405   {
   9406     return MemoryPropertyFlags( bit0 ) | bit1;
   9407   }
   9408 
   9409   struct MemoryType
   9410   {
   9411     operator const VkMemoryType&() const
   9412     {
   9413       return *reinterpret_cast<const VkMemoryType*>(this);
   9414     }
   9415 
   9416     bool operator==( MemoryType const& rhs ) const
   9417     {
   9418       return ( propertyFlags == rhs.propertyFlags )
   9419           && ( heapIndex == rhs.heapIndex );
   9420     }
   9421 
   9422     bool operator!=( MemoryType const& rhs ) const
   9423     {
   9424       return !operator==( rhs );
   9425     }
   9426 
   9427     MemoryPropertyFlags propertyFlags;
   9428     uint32_t heapIndex;
   9429   };
   9430   static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
   9431 
   9432   enum class MemoryHeapFlagBits
   9433   {
   9434     eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
   9435   };
   9436 
   9437   using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
   9438 
   9439   inline MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
   9440   {
   9441     return MemoryHeapFlags( bit0 ) | bit1;
   9442   }
   9443 
   9444   struct MemoryHeap
   9445   {
   9446     operator const VkMemoryHeap&() const
   9447     {
   9448       return *reinterpret_cast<const VkMemoryHeap*>(this);
   9449     }
   9450 
   9451     bool operator==( MemoryHeap const& rhs ) const
   9452     {
   9453       return ( size == rhs.size )
   9454           && ( flags == rhs.flags );
   9455     }
   9456 
   9457     bool operator!=( MemoryHeap const& rhs ) const
   9458     {
   9459       return !operator==( rhs );
   9460     }
   9461 
   9462     DeviceSize size;
   9463     MemoryHeapFlags flags;
   9464   };
   9465   static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
   9466 
   9467   struct PhysicalDeviceMemoryProperties
   9468   {
   9469     operator const VkPhysicalDeviceMemoryProperties&() const
   9470     {
   9471       return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
   9472     }
   9473 
   9474     bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
   9475     {
   9476       return ( memoryTypeCount == rhs.memoryTypeCount )
   9477           && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
   9478           && ( memoryHeapCount == rhs.memoryHeapCount )
   9479           && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
   9480     }
   9481 
   9482     bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
   9483     {
   9484       return !operator==( rhs );
   9485     }
   9486 
   9487     uint32_t memoryTypeCount;
   9488     MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
   9489     uint32_t memoryHeapCount;
   9490     MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
   9491   };
   9492   static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
   9493 
   9494   enum class AccessFlagBits
   9495   {
   9496     eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
   9497     eIndexRead = VK_ACCESS_INDEX_READ_BIT,
   9498     eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
   9499     eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
   9500     eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
   9501     eShaderRead = VK_ACCESS_SHADER_READ_BIT,
   9502     eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
   9503     eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
   9504     eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
   9505     eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
   9506     eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
   9507     eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
   9508     eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
   9509     eHostRead = VK_ACCESS_HOST_READ_BIT,
   9510     eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
   9511     eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
   9512     eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT
   9513   };
   9514 
   9515   using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
   9516 
   9517   inline AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
   9518   {
   9519     return AccessFlags( bit0 ) | bit1;
   9520   }
   9521 
   9522   struct MemoryBarrier
   9523   {
   9524     MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() )
   9525       : sType( StructureType::eMemoryBarrier )
   9526       , pNext( nullptr )
   9527       , srcAccessMask( srcAccessMask_ )
   9528       , dstAccessMask( dstAccessMask_ )
   9529     {
   9530     }
   9531 
   9532     MemoryBarrier( VkMemoryBarrier const & rhs )
   9533     {
   9534       memcpy( this, &rhs, sizeof(MemoryBarrier) );
   9535     }
   9536 
   9537     MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
   9538     {
   9539       memcpy( this, &rhs, sizeof(MemoryBarrier) );
   9540       return *this;
   9541     }
   9542 
   9543     MemoryBarrier& setSType( StructureType sType_ )
   9544     {
   9545       sType = sType_;
   9546       return *this;
   9547     }
   9548 
   9549     MemoryBarrier& setPNext( const void* pNext_ )
   9550     {
   9551       pNext = pNext_;
   9552       return *this;
   9553     }
   9554 
   9555     MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
   9556     {
   9557       srcAccessMask = srcAccessMask_;
   9558       return *this;
   9559     }
   9560 
   9561     MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
   9562     {
   9563       dstAccessMask = dstAccessMask_;
   9564       return *this;
   9565     }
   9566 
   9567     operator const VkMemoryBarrier&() const
   9568     {
   9569       return *reinterpret_cast<const VkMemoryBarrier*>(this);
   9570     }
   9571 
   9572     bool operator==( MemoryBarrier const& rhs ) const
   9573     {
   9574       return ( sType == rhs.sType )
   9575           && ( pNext == rhs.pNext )
   9576           && ( srcAccessMask == rhs.srcAccessMask )
   9577           && ( dstAccessMask == rhs.dstAccessMask );
   9578     }
   9579 
   9580     bool operator!=( MemoryBarrier const& rhs ) const
   9581     {
   9582       return !operator==( rhs );
   9583     }
   9584 
   9585   private:
   9586     StructureType sType;
   9587 
   9588   public:
   9589     const void* pNext;
   9590     AccessFlags srcAccessMask;
   9591     AccessFlags dstAccessMask;
   9592   };
   9593   static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
   9594 
   9595   struct BufferMemoryBarrier
   9596   {
   9597     BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
   9598       : sType( StructureType::eBufferMemoryBarrier )
   9599       , pNext( nullptr )
   9600       , srcAccessMask( srcAccessMask_ )
   9601       , dstAccessMask( dstAccessMask_ )
   9602       , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
   9603       , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
   9604       , buffer( buffer_ )
   9605       , offset( offset_ )
   9606       , size( size_ )
   9607     {
   9608     }
   9609 
   9610     BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
   9611     {
   9612       memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
   9613     }
   9614 
   9615     BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
   9616     {
   9617       memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
   9618       return *this;
   9619     }
   9620 
   9621     BufferMemoryBarrier& setSType( StructureType sType_ )
   9622     {
   9623       sType = sType_;
   9624       return *this;
   9625     }
   9626 
   9627     BufferMemoryBarrier& setPNext( const void* pNext_ )
   9628     {
   9629       pNext = pNext_;
   9630       return *this;
   9631     }
   9632 
   9633     BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
   9634     {
   9635       srcAccessMask = srcAccessMask_;
   9636       return *this;
   9637     }
   9638 
   9639     BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
   9640     {
   9641       dstAccessMask = dstAccessMask_;
   9642       return *this;
   9643     }
   9644 
   9645     BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
   9646     {
   9647       srcQueueFamilyIndex = srcQueueFamilyIndex_;
   9648       return *this;
   9649     }
   9650 
   9651     BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
   9652     {
   9653       dstQueueFamilyIndex = dstQueueFamilyIndex_;
   9654       return *this;
   9655     }
   9656 
   9657     BufferMemoryBarrier& setBuffer( Buffer buffer_ )
   9658     {
   9659       buffer = buffer_;
   9660       return *this;
   9661     }
   9662 
   9663     BufferMemoryBarrier& setOffset( DeviceSize offset_ )
   9664     {
   9665       offset = offset_;
   9666       return *this;
   9667     }
   9668 
   9669     BufferMemoryBarrier& setSize( DeviceSize size_ )
   9670     {
   9671       size = size_;
   9672       return *this;
   9673     }
   9674 
   9675     operator const VkBufferMemoryBarrier&() const
   9676     {
   9677       return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
   9678     }
   9679 
   9680     bool operator==( BufferMemoryBarrier const& rhs ) const
   9681     {
   9682       return ( sType == rhs.sType )
   9683           && ( pNext == rhs.pNext )
   9684           && ( srcAccessMask == rhs.srcAccessMask )
   9685           && ( dstAccessMask == rhs.dstAccessMask )
   9686           && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
   9687           && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
   9688           && ( buffer == rhs.buffer )
   9689           && ( offset == rhs.offset )
   9690           && ( size == rhs.size );
   9691     }
   9692 
   9693     bool operator!=( BufferMemoryBarrier const& rhs ) const
   9694     {
   9695       return !operator==( rhs );
   9696     }
   9697 
   9698   private:
   9699     StructureType sType;
   9700 
   9701   public:
   9702     const void* pNext;
   9703     AccessFlags srcAccessMask;
   9704     AccessFlags dstAccessMask;
   9705     uint32_t srcQueueFamilyIndex;
   9706     uint32_t dstQueueFamilyIndex;
   9707     Buffer buffer;
   9708     DeviceSize offset;
   9709     DeviceSize size;
   9710   };
   9711   static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
   9712 
   9713   enum class BufferUsageFlagBits
   9714   {
   9715     eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
   9716     eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
   9717     eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
   9718     eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
   9719     eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
   9720     eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
   9721     eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
   9722     eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
   9723     eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
   9724   };
   9725 
   9726   using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
   9727 
   9728   inline BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
   9729   {
   9730     return BufferUsageFlags( bit0 ) | bit1;
   9731   }
   9732 
   9733   enum class BufferCreateFlagBits
   9734   {
   9735     eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
   9736     eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
   9737     eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
   9738   };
   9739 
   9740   using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
   9741 
   9742   inline BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
   9743   {
   9744     return BufferCreateFlags( bit0 ) | bit1;
   9745   }
   9746 
   9747   struct BufferCreateInfo
   9748   {
   9749     BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr )
   9750       : sType( StructureType::eBufferCreateInfo )
   9751       , pNext( nullptr )
   9752       , flags( flags_ )
   9753       , size( size_ )
   9754       , usage( usage_ )
   9755       , sharingMode( sharingMode_ )
   9756       , queueFamilyIndexCount( queueFamilyIndexCount_ )
   9757       , pQueueFamilyIndices( pQueueFamilyIndices_ )
   9758     {
   9759     }
   9760 
   9761     BufferCreateInfo( VkBufferCreateInfo const & rhs )
   9762     {
   9763       memcpy( this, &rhs, sizeof(BufferCreateInfo) );
   9764     }
   9765 
   9766     BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
   9767     {
   9768       memcpy( this, &rhs, sizeof(BufferCreateInfo) );
   9769       return *this;
   9770     }
   9771 
   9772     BufferCreateInfo& setSType( StructureType sType_ )
   9773     {
   9774       sType = sType_;
   9775       return *this;
   9776     }
   9777 
   9778     BufferCreateInfo& setPNext( const void* pNext_ )
   9779     {
   9780       pNext = pNext_;
   9781       return *this;
   9782     }
   9783 
   9784     BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
   9785     {
   9786       flags = flags_;
   9787       return *this;
   9788     }
   9789 
   9790     BufferCreateInfo& setSize( DeviceSize size_ )
   9791     {
   9792       size = size_;
   9793       return *this;
   9794     }
   9795 
   9796     BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
   9797     {
   9798       usage = usage_;
   9799       return *this;
   9800     }
   9801 
   9802     BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
   9803     {
   9804       sharingMode = sharingMode_;
   9805       return *this;
   9806     }
   9807 
   9808     BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
   9809     {
   9810       queueFamilyIndexCount = queueFamilyIndexCount_;
   9811       return *this;
   9812     }
   9813 
   9814     BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
   9815     {
   9816       pQueueFamilyIndices = pQueueFamilyIndices_;
   9817       return *this;
   9818     }
   9819 
   9820     operator const VkBufferCreateInfo&() const
   9821     {
   9822       return *reinterpret_cast<const VkBufferCreateInfo*>(this);
   9823     }
   9824 
   9825     bool operator==( BufferCreateInfo const& rhs ) const
   9826     {
   9827       return ( sType == rhs.sType )
   9828           && ( pNext == rhs.pNext )
   9829           && ( flags == rhs.flags )
   9830           && ( size == rhs.size )
   9831           && ( usage == rhs.usage )
   9832           && ( sharingMode == rhs.sharingMode )
   9833           && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
   9834           && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
   9835     }
   9836 
   9837     bool operator!=( BufferCreateInfo const& rhs ) const
   9838     {
   9839       return !operator==( rhs );
   9840     }
   9841 
   9842   private:
   9843     StructureType sType;
   9844 
   9845   public:
   9846     const void* pNext;
   9847     BufferCreateFlags flags;
   9848     DeviceSize size;
   9849     BufferUsageFlags usage;
   9850     SharingMode sharingMode;
   9851     uint32_t queueFamilyIndexCount;
   9852     const uint32_t* pQueueFamilyIndices;
   9853   };
   9854   static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
   9855 
   9856   enum class ShaderStageFlagBits
   9857   {
   9858     eVertex = VK_SHADER_STAGE_VERTEX_BIT,
   9859     eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
   9860     eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
   9861     eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
   9862     eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
   9863     eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
   9864     eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
   9865     eAll = VK_SHADER_STAGE_ALL
   9866   };
   9867 
   9868   using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
   9869 
   9870   inline ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
   9871   {
   9872     return ShaderStageFlags( bit0 ) | bit1;
   9873   }
   9874 
   9875   struct DescriptorSetLayoutBinding
   9876   {
   9877     DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr )
   9878       : binding( binding_ )
   9879       , descriptorType( descriptorType_ )
   9880       , descriptorCount( descriptorCount_ )
   9881       , stageFlags( stageFlags_ )
   9882       , pImmutableSamplers( pImmutableSamplers_ )
   9883     {
   9884     }
   9885 
   9886     DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
   9887     {
   9888       memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
   9889     }
   9890 
   9891     DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
   9892     {
   9893       memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
   9894       return *this;
   9895     }
   9896 
   9897     DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
   9898     {
   9899       binding = binding_;
   9900       return *this;
   9901     }
   9902 
   9903     DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
   9904     {
   9905       descriptorType = descriptorType_;
   9906       return *this;
   9907     }
   9908 
   9909     DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
   9910     {
   9911       descriptorCount = descriptorCount_;
   9912       return *this;
   9913     }
   9914 
   9915     DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
   9916     {
   9917       stageFlags = stageFlags_;
   9918       return *this;
   9919     }
   9920 
   9921     DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
   9922     {
   9923       pImmutableSamplers = pImmutableSamplers_;
   9924       return *this;
   9925     }
   9926 
   9927     operator const VkDescriptorSetLayoutBinding&() const
   9928     {
   9929       return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
   9930     }
   9931 
   9932     bool operator==( DescriptorSetLayoutBinding const& rhs ) const
   9933     {
   9934       return ( binding == rhs.binding )
   9935           && ( descriptorType == rhs.descriptorType )
   9936           && ( descriptorCount == rhs.descriptorCount )
   9937           && ( stageFlags == rhs.stageFlags )
   9938           && ( pImmutableSamplers == rhs.pImmutableSamplers );
   9939     }
   9940 
   9941     bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
   9942     {
   9943       return !operator==( rhs );
   9944     }
   9945 
   9946     uint32_t binding;
   9947     DescriptorType descriptorType;
   9948     uint32_t descriptorCount;
   9949     ShaderStageFlags stageFlags;
   9950     const Sampler* pImmutableSamplers;
   9951   };
   9952   static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
   9953 
   9954   struct DescriptorSetLayoutCreateInfo
   9955   {
   9956     DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr )
   9957       : sType( StructureType::eDescriptorSetLayoutCreateInfo )
   9958       , pNext( nullptr )
   9959       , flags( flags_ )
   9960       , bindingCount( bindingCount_ )
   9961       , pBindings( pBindings_ )
   9962     {
   9963     }
   9964 
   9965     DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
   9966     {
   9967       memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
   9968     }
   9969 
   9970     DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
   9971     {
   9972       memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
   9973       return *this;
   9974     }
   9975 
   9976     DescriptorSetLayoutCreateInfo& setSType( StructureType sType_ )
   9977     {
   9978       sType = sType_;
   9979       return *this;
   9980     }
   9981 
   9982     DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
   9983     {
   9984       pNext = pNext_;
   9985       return *this;
   9986     }
   9987 
   9988     DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
   9989     {
   9990       flags = flags_;
   9991       return *this;
   9992     }
   9993 
   9994     DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
   9995     {
   9996       bindingCount = bindingCount_;
   9997       return *this;
   9998     }
   9999 
   10000     DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
   10001     {
   10002       pBindings = pBindings_;
   10003       return *this;
   10004     }
   10005 
   10006     operator const VkDescriptorSetLayoutCreateInfo&() const
   10007     {
   10008       return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
   10009     }
   10010 
   10011     bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
   10012     {
   10013       return ( sType == rhs.sType )
   10014           && ( pNext == rhs.pNext )
   10015           && ( flags == rhs.flags )
   10016           && ( bindingCount == rhs.bindingCount )
   10017           && ( pBindings == rhs.pBindings );
   10018     }
   10019 
   10020     bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
   10021     {
   10022       return !operator==( rhs );
   10023     }
   10024 
   10025   private:
   10026     StructureType sType;
   10027 
   10028   public:
   10029     const void* pNext;
   10030     DescriptorSetLayoutCreateFlags flags;
   10031     uint32_t bindingCount;
   10032     const DescriptorSetLayoutBinding* pBindings;
   10033   };
   10034   static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
   10035 
   10036   struct PipelineShaderStageCreateInfo
   10037   {
   10038     PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr )
   10039       : sType( StructureType::ePipelineShaderStageCreateInfo )
   10040       , pNext( nullptr )
   10041       , flags( flags_ )
   10042       , stage( stage_ )
   10043       , module( module_ )
   10044       , pName( pName_ )
   10045       , pSpecializationInfo( pSpecializationInfo_ )
   10046     {
   10047     }
   10048 
   10049     PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
   10050     {
   10051       memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
   10052     }
   10053 
   10054     PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
   10055     {
   10056       memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
   10057       return *this;
   10058     }
   10059 
   10060     PipelineShaderStageCreateInfo& setSType( StructureType sType_ )
   10061     {
   10062       sType = sType_;
   10063       return *this;
   10064     }
   10065 
   10066     PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
   10067     {
   10068       pNext = pNext_;
   10069       return *this;
   10070     }
   10071 
   10072     PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
   10073     {
   10074       flags = flags_;
   10075       return *this;
   10076     }
   10077 
   10078     PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
   10079     {
   10080       stage = stage_;
   10081       return *this;
   10082     }
   10083 
   10084     PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
   10085     {
   10086       module = module_;
   10087       return *this;
   10088     }
   10089 
   10090     PipelineShaderStageCreateInfo& setPName( const char* pName_ )
   10091     {
   10092       pName = pName_;
   10093       return *this;
   10094     }
   10095 
   10096     PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
   10097     {
   10098       pSpecializationInfo = pSpecializationInfo_;
   10099       return *this;
   10100     }
   10101 
   10102     operator const VkPipelineShaderStageCreateInfo&() const
   10103     {
   10104       return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
   10105     }
   10106 
   10107     bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
   10108     {
   10109       return ( sType == rhs.sType )
   10110           && ( pNext == rhs.pNext )
   10111           && ( flags == rhs.flags )
   10112           && ( stage == rhs.stage )
   10113           && ( module == rhs.module )
   10114           && ( pName == rhs.pName )
   10115           && ( pSpecializationInfo == rhs.pSpecializationInfo );
   10116     }
   10117 
   10118     bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
   10119     {
   10120       return !operator==( rhs );
   10121     }
   10122 
   10123   private:
   10124     StructureType sType;
   10125 
   10126   public:
   10127     const void* pNext;
   10128     PipelineShaderStageCreateFlags flags;
   10129     ShaderStageFlagBits stage;
   10130     ShaderModule module;
   10131     const char* pName;
   10132     const SpecializationInfo* pSpecializationInfo;
   10133   };
   10134   static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
   10135 
   10136   struct PushConstantRange
   10137   {
   10138     PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 )
   10139       : stageFlags( stageFlags_ )
   10140       , offset( offset_ )
   10141       , size( size_ )
   10142     {
   10143     }
   10144 
   10145     PushConstantRange( VkPushConstantRange const & rhs )
   10146     {
   10147       memcpy( this, &rhs, sizeof(PushConstantRange) );
   10148     }
   10149 
   10150     PushConstantRange& operator=( VkPushConstantRange const & rhs )
   10151     {
   10152       memcpy( this, &rhs, sizeof(PushConstantRange) );
   10153       return *this;
   10154     }
   10155 
   10156     PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
   10157     {
   10158       stageFlags = stageFlags_;
   10159       return *this;
   10160     }
   10161 
   10162     PushConstantRange& setOffset( uint32_t offset_ )
   10163     {
   10164       offset = offset_;
   10165       return *this;
   10166     }
   10167 
   10168     PushConstantRange& setSize( uint32_t size_ )
   10169     {
   10170       size = size_;
   10171       return *this;
   10172     }
   10173 
   10174     operator const VkPushConstantRange&() const
   10175     {
   10176       return *reinterpret_cast<const VkPushConstantRange*>(this);
   10177     }
   10178 
   10179     bool operator==( PushConstantRange const& rhs ) const
   10180     {
   10181       return ( stageFlags == rhs.stageFlags )
   10182           && ( offset == rhs.offset )
   10183           && ( size == rhs.size );
   10184     }
   10185 
   10186     bool operator!=( PushConstantRange const& rhs ) const
   10187     {
   10188       return !operator==( rhs );
   10189     }
   10190 
   10191     ShaderStageFlags stageFlags;
   10192     uint32_t offset;
   10193     uint32_t size;
   10194   };
   10195   static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
   10196 
   10197   struct PipelineLayoutCreateInfo
   10198   {
   10199     PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr )
   10200       : sType( StructureType::ePipelineLayoutCreateInfo )
   10201       , pNext( nullptr )
   10202       , flags( flags_ )
   10203       , setLayoutCount( setLayoutCount_ )
   10204       , pSetLayouts( pSetLayouts_ )
   10205       , pushConstantRangeCount( pushConstantRangeCount_ )
   10206       , pPushConstantRanges( pPushConstantRanges_ )
   10207     {
   10208     }
   10209 
   10210     PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
   10211     {
   10212       memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
   10213     }
   10214 
   10215     PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
   10216     {
   10217       memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
   10218       return *this;
   10219     }
   10220 
   10221     PipelineLayoutCreateInfo& setSType( StructureType sType_ )
   10222     {
   10223       sType = sType_;
   10224       return *this;
   10225     }
   10226 
   10227     PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
   10228     {
   10229       pNext = pNext_;
   10230       return *this;
   10231     }
   10232 
   10233     PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
   10234     {
   10235       flags = flags_;
   10236       return *this;
   10237     }
   10238 
   10239     PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
   10240     {
   10241       setLayoutCount = setLayoutCount_;
   10242       return *this;
   10243     }
   10244 
   10245     PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
   10246     {
   10247       pSetLayouts = pSetLayouts_;
   10248       return *this;
   10249     }
   10250 
   10251     PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
   10252     {
   10253       pushConstantRangeCount = pushConstantRangeCount_;
   10254       return *this;
   10255     }
   10256 
   10257     PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
   10258     {
   10259       pPushConstantRanges = pPushConstantRanges_;
   10260       return *this;
   10261     }
   10262 
   10263     operator const VkPipelineLayoutCreateInfo&() const
   10264     {
   10265       return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
   10266     }
   10267 
   10268     bool operator==( PipelineLayoutCreateInfo const& rhs ) const
   10269     {
   10270       return ( sType == rhs.sType )
   10271           && ( pNext == rhs.pNext )
   10272           && ( flags == rhs.flags )
   10273           && ( setLayoutCount == rhs.setLayoutCount )
   10274           && ( pSetLayouts == rhs.pSetLayouts )
   10275           && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
   10276           && ( pPushConstantRanges == rhs.pPushConstantRanges );
   10277     }
   10278 
   10279     bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
   10280     {
   10281       return !operator==( rhs );
   10282     }
   10283 
   10284   private:
   10285     StructureType sType;
   10286 
   10287   public:
   10288     const void* pNext;
   10289     PipelineLayoutCreateFlags flags;
   10290     uint32_t setLayoutCount;
   10291     const DescriptorSetLayout* pSetLayouts;
   10292     uint32_t pushConstantRangeCount;
   10293     const PushConstantRange* pPushConstantRanges;
   10294   };
   10295   static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
   10296 
   10297   enum class ImageUsageFlagBits
   10298   {
   10299     eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
   10300     eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
   10301     eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
   10302     eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
   10303     eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
   10304     eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
   10305     eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
   10306     eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
   10307   };
   10308 
   10309   using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
   10310 
   10311   inline ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
   10312   {
   10313     return ImageUsageFlags( bit0 ) | bit1;
   10314   }
   10315 
   10316   enum class ImageCreateFlagBits
   10317   {
   10318     eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
   10319     eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
   10320     eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
   10321     eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
   10322     eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
   10323   };
   10324 
   10325   using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
   10326 
   10327   inline ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
   10328   {
   10329     return ImageCreateFlags( bit0 ) | bit1;
   10330   }
   10331 
   10332   enum class PipelineCreateFlagBits
   10333   {
   10334     eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
   10335     eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
   10336     eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT
   10337   };
   10338 
   10339   using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
   10340 
   10341   inline PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
   10342   {
   10343     return PipelineCreateFlags( bit0 ) | bit1;
   10344   }
   10345 
   10346   struct ComputePipelineCreateInfo
   10347   {
   10348     ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
   10349       : sType( StructureType::eComputePipelineCreateInfo )
   10350       , pNext( nullptr )
   10351       , flags( flags_ )
   10352       , stage( stage_ )
   10353       , layout( layout_ )
   10354       , basePipelineHandle( basePipelineHandle_ )
   10355       , basePipelineIndex( basePipelineIndex_ )
   10356     {
   10357     }
   10358 
   10359     ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
   10360     {
   10361       memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
   10362     }
   10363 
   10364     ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
   10365     {
   10366       memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
   10367       return *this;
   10368     }
   10369 
   10370     ComputePipelineCreateInfo& setSType( StructureType sType_ )
   10371     {
   10372       sType = sType_;
   10373       return *this;
   10374     }
   10375 
   10376     ComputePipelineCreateInfo& setPNext( const void* pNext_ )
   10377     {
   10378       pNext = pNext_;
   10379       return *this;
   10380     }
   10381 
   10382     ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
   10383     {
   10384       flags = flags_;
   10385       return *this;
   10386     }
   10387 
   10388     ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
   10389     {
   10390       stage = stage_;
   10391       return *this;
   10392     }
   10393 
   10394     ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
   10395     {
   10396       layout = layout_;
   10397       return *this;
   10398     }
   10399 
   10400     ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
   10401     {
   10402       basePipelineHandle = basePipelineHandle_;
   10403       return *this;
   10404     }
   10405 
   10406     ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
   10407     {
   10408       basePipelineIndex = basePipelineIndex_;
   10409       return *this;
   10410     }
   10411 
   10412     operator const VkComputePipelineCreateInfo&() const
   10413     {
   10414       return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
   10415     }
   10416 
   10417     bool operator==( ComputePipelineCreateInfo const& rhs ) const
   10418     {
   10419       return ( sType == rhs.sType )
   10420           && ( pNext == rhs.pNext )
   10421           && ( flags == rhs.flags )
   10422           && ( stage == rhs.stage )
   10423           && ( layout == rhs.layout )
   10424           && ( basePipelineHandle == rhs.basePipelineHandle )
   10425           && ( basePipelineIndex == rhs.basePipelineIndex );
   10426     }
   10427 
   10428     bool operator!=( ComputePipelineCreateInfo const& rhs ) const
   10429     {
   10430       return !operator==( rhs );
   10431     }
   10432 
   10433   private:
   10434     StructureType sType;
   10435 
   10436   public:
   10437     const void* pNext;
   10438     PipelineCreateFlags flags;
   10439     PipelineShaderStageCreateInfo stage;
   10440     PipelineLayout layout;
   10441     Pipeline basePipelineHandle;
   10442     int32_t basePipelineIndex;
   10443   };
   10444   static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
   10445 
   10446   enum class ColorComponentFlagBits
   10447   {
   10448     eR = VK_COLOR_COMPONENT_R_BIT,
   10449     eG = VK_COLOR_COMPONENT_G_BIT,
   10450     eB = VK_COLOR_COMPONENT_B_BIT,
   10451     eA = VK_COLOR_COMPONENT_A_BIT
   10452   };
   10453 
   10454   using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
   10455 
   10456   inline ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
   10457   {
   10458     return ColorComponentFlags( bit0 ) | bit1;
   10459   }
   10460 
   10461   struct PipelineColorBlendAttachmentState
   10462   {
   10463     PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, BlendOp colorBlendOp_ = BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, BlendOp alphaBlendOp_ = BlendOp::eAdd, ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
   10464       : blendEnable( blendEnable_ )
   10465       , srcColorBlendFactor( srcColorBlendFactor_ )
   10466       , dstColorBlendFactor( dstColorBlendFactor_ )
   10467       , colorBlendOp( colorBlendOp_ )
   10468       , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
   10469       , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
   10470       , alphaBlendOp( alphaBlendOp_ )
   10471       , colorWriteMask( colorWriteMask_ )
   10472     {
   10473     }
   10474 
   10475     PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
   10476     {
   10477       memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
   10478     }
   10479 
   10480     PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
   10481     {
   10482       memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
   10483       return *this;
   10484     }
   10485 
   10486     PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
   10487     {
   10488       blendEnable = blendEnable_;
   10489       return *this;
   10490     }
   10491 
   10492     PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
   10493     {
   10494       srcColorBlendFactor = srcColorBlendFactor_;
   10495       return *this;
   10496     }
   10497 
   10498     PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
   10499     {
   10500       dstColorBlendFactor = dstColorBlendFactor_;
   10501       return *this;
   10502     }
   10503 
   10504     PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
   10505     {
   10506       colorBlendOp = colorBlendOp_;
   10507       return *this;
   10508     }
   10509 
   10510     PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
   10511     {
   10512       srcAlphaBlendFactor = srcAlphaBlendFactor_;
   10513       return *this;
   10514     }
   10515 
   10516     PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
   10517     {
   10518       dstAlphaBlendFactor = dstAlphaBlendFactor_;
   10519       return *this;
   10520     }
   10521 
   10522     PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
   10523     {
   10524       alphaBlendOp = alphaBlendOp_;
   10525       return *this;
   10526     }
   10527 
   10528     PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
   10529     {
   10530       colorWriteMask = colorWriteMask_;
   10531       return *this;
   10532     }
   10533 
   10534     operator const VkPipelineColorBlendAttachmentState&() const
   10535     {
   10536       return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
   10537     }
   10538 
   10539     bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
   10540     {
   10541       return ( blendEnable == rhs.blendEnable )
   10542           && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
   10543           && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
   10544           && ( colorBlendOp == rhs.colorBlendOp )
   10545           && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
   10546           && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
   10547           && ( alphaBlendOp == rhs.alphaBlendOp )
   10548           && ( colorWriteMask == rhs.colorWriteMask );
   10549     }
   10550 
   10551     bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
   10552     {
   10553       return !operator==( rhs );
   10554     }
   10555 
   10556     Bool32 blendEnable;
   10557     BlendFactor srcColorBlendFactor;
   10558     BlendFactor dstColorBlendFactor;
   10559     BlendOp colorBlendOp;
   10560     BlendFactor srcAlphaBlendFactor;
   10561     BlendFactor dstAlphaBlendFactor;
   10562     BlendOp alphaBlendOp;
   10563     ColorComponentFlags colorWriteMask;
   10564   };
   10565   static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
   10566 
   10567   struct PipelineColorBlendStateCreateInfo
   10568   {
   10569     PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
   10570       : sType( StructureType::ePipelineColorBlendStateCreateInfo )
   10571       , pNext( nullptr )
   10572       , flags( flags_ )
   10573       , logicOpEnable( logicOpEnable_ )
   10574       , logicOp( logicOp_ )
   10575       , attachmentCount( attachmentCount_ )
   10576       , pAttachments( pAttachments_ )
   10577     {
   10578       memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
   10579     }
   10580 
   10581     PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
   10582     {
   10583       memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
   10584     }
   10585 
   10586     PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
   10587     {
   10588       memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
   10589       return *this;
   10590     }
   10591 
   10592     PipelineColorBlendStateCreateInfo& setSType( StructureType sType_ )
   10593     {
   10594       sType = sType_;
   10595       return *this;
   10596     }
   10597 
   10598     PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
   10599     {
   10600       pNext = pNext_;
   10601       return *this;
   10602     }
   10603 
   10604     PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
   10605     {
   10606       flags = flags_;
   10607       return *this;
   10608     }
   10609 
   10610     PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
   10611     {
   10612       logicOpEnable = logicOpEnable_;
   10613       return *this;
   10614     }
   10615 
   10616     PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
   10617     {
   10618       logicOp = logicOp_;
   10619       return *this;
   10620     }
   10621 
   10622     PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
   10623     {
   10624       attachmentCount = attachmentCount_;
   10625       return *this;
   10626     }
   10627 
   10628     PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
   10629     {
   10630       pAttachments = pAttachments_;
   10631       return *this;
   10632     }
   10633 
   10634     PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
   10635     {
   10636       memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
   10637       return *this;
   10638     }
   10639 
   10640     operator const VkPipelineColorBlendStateCreateInfo&() const
   10641     {
   10642       return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
   10643     }
   10644 
   10645     bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
   10646     {
   10647       return ( sType == rhs.sType )
   10648           && ( pNext == rhs.pNext )
   10649           && ( flags == rhs.flags )
   10650           && ( logicOpEnable == rhs.logicOpEnable )
   10651           && ( logicOp == rhs.logicOp )
   10652           && ( attachmentCount == rhs.attachmentCount )
   10653           && ( pAttachments == rhs.pAttachments )
   10654           && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
   10655     }
   10656 
   10657     bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
   10658     {
   10659       return !operator==( rhs );
   10660     }
   10661 
   10662   private:
   10663     StructureType sType;
   10664 
   10665   public:
   10666     const void* pNext;
   10667     PipelineColorBlendStateCreateFlags flags;
   10668     Bool32 logicOpEnable;
   10669     LogicOp logicOp;
   10670     uint32_t attachmentCount;
   10671     const PipelineColorBlendAttachmentState* pAttachments;
   10672     float blendConstants[4];
   10673   };
   10674   static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
   10675 
   10676   enum class FenceCreateFlagBits
   10677   {
   10678     eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
   10679   };
   10680 
   10681   using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
   10682 
   10683   inline FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
   10684   {
   10685     return FenceCreateFlags( bit0 ) | bit1;
   10686   }
   10687 
   10688   struct FenceCreateInfo
   10689   {
   10690     FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
   10691       : sType( StructureType::eFenceCreateInfo )
   10692       , pNext( nullptr )
   10693       , flags( flags_ )
   10694     {
   10695     }
   10696 
   10697     FenceCreateInfo( VkFenceCreateInfo const & rhs )
   10698     {
   10699       memcpy( this, &rhs, sizeof(FenceCreateInfo) );
   10700     }
   10701 
   10702     FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
   10703     {
   10704       memcpy( this, &rhs, sizeof(FenceCreateInfo) );
   10705       return *this;
   10706     }
   10707 
   10708     FenceCreateInfo& setSType( StructureType sType_ )
   10709     {
   10710       sType = sType_;
   10711       return *this;
   10712     }
   10713 
   10714     FenceCreateInfo& setPNext( const void* pNext_ )
   10715     {
   10716       pNext = pNext_;
   10717       return *this;
   10718     }
   10719 
   10720     FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
   10721     {
   10722       flags = flags_;
   10723       return *this;
   10724     }
   10725 
   10726     operator const VkFenceCreateInfo&() const
   10727     {
   10728       return *reinterpret_cast<const VkFenceCreateInfo*>(this);
   10729     }
   10730 
   10731     bool operator==( FenceCreateInfo const& rhs ) const
   10732     {
   10733       return ( sType == rhs.sType )
   10734           && ( pNext == rhs.pNext )
   10735           && ( flags == rhs.flags );
   10736     }
   10737 
   10738     bool operator!=( FenceCreateInfo const& rhs ) const
   10739     {
   10740       return !operator==( rhs );
   10741     }
   10742 
   10743   private:
   10744     StructureType sType;
   10745 
   10746   public:
   10747     const void* pNext;
   10748     FenceCreateFlags flags;
   10749   };
   10750   static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
   10751 
   10752   enum class FormatFeatureFlagBits
   10753   {
   10754     eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
   10755     eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
   10756     eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
   10757     eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
   10758     eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
   10759     eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
   10760     eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
   10761     eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
   10762     eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
   10763     eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
   10764     eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
   10765     eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
   10766     eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
   10767     eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG
   10768   };
   10769 
   10770   using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
   10771 
   10772   inline FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
   10773   {
   10774     return FormatFeatureFlags( bit0 ) | bit1;
   10775   }
   10776 
   10777   struct FormatProperties
   10778   {
   10779     operator const VkFormatProperties&() const
   10780     {
   10781       return *reinterpret_cast<const VkFormatProperties*>(this);
   10782     }
   10783 
   10784     bool operator==( FormatProperties const& rhs ) const
   10785     {
   10786       return ( linearTilingFeatures == rhs.linearTilingFeatures )
   10787           && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
   10788           && ( bufferFeatures == rhs.bufferFeatures );
   10789     }
   10790 
   10791     bool operator!=( FormatProperties const& rhs ) const
   10792     {
   10793       return !operator==( rhs );
   10794     }
   10795 
   10796     FormatFeatureFlags linearTilingFeatures;
   10797     FormatFeatureFlags optimalTilingFeatures;
   10798     FormatFeatureFlags bufferFeatures;
   10799   };
   10800   static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
   10801 
   10802   enum class QueryControlFlagBits
   10803   {
   10804     ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
   10805   };
   10806 
   10807   using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
   10808 
   10809   inline QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
   10810   {
   10811     return QueryControlFlags( bit0 ) | bit1;
   10812   }
   10813 
   10814   enum class QueryResultFlagBits
   10815   {
   10816     e64 = VK_QUERY_RESULT_64_BIT,
   10817     eWait = VK_QUERY_RESULT_WAIT_BIT,
   10818     eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
   10819     ePartial = VK_QUERY_RESULT_PARTIAL_BIT
   10820   };
   10821 
   10822   using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
   10823 
   10824   inline QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
   10825   {
   10826     return QueryResultFlags( bit0 ) | bit1;
   10827   }
   10828 
   10829   enum class CommandBufferUsageFlagBits
   10830   {
   10831     eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
   10832     eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
   10833     eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
   10834   };
   10835 
   10836   using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
   10837 
   10838   inline CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
   10839   {
   10840     return CommandBufferUsageFlags( bit0 ) | bit1;
   10841   }
   10842 
   10843   enum class QueryPipelineStatisticFlagBits
   10844   {
   10845     eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
   10846     eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
   10847     eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
   10848     eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
   10849     eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
   10850     eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
   10851     eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
   10852     eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
   10853     eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
   10854     eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
   10855     eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
   10856   };
   10857 
   10858   using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
   10859 
   10860   inline QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
   10861   {
   10862     return QueryPipelineStatisticFlags( bit0 ) | bit1;
   10863   }
   10864 
   10865   struct CommandBufferInheritanceInfo
   10866   {
   10867     CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
   10868       : sType( StructureType::eCommandBufferInheritanceInfo )
   10869       , pNext( nullptr )
   10870       , renderPass( renderPass_ )
   10871       , subpass( subpass_ )
   10872       , framebuffer( framebuffer_ )
   10873       , occlusionQueryEnable( occlusionQueryEnable_ )
   10874       , queryFlags( queryFlags_ )
   10875       , pipelineStatistics( pipelineStatistics_ )
   10876     {
   10877     }
   10878 
   10879     CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
   10880     {
   10881       memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
   10882     }
   10883 
   10884     CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
   10885     {
   10886       memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
   10887       return *this;
   10888     }
   10889 
   10890     CommandBufferInheritanceInfo& setSType( StructureType sType_ )
   10891     {
   10892       sType = sType_;
   10893       return *this;
   10894     }
   10895 
   10896     CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
   10897     {
   10898       pNext = pNext_;
   10899       return *this;
   10900     }
   10901 
   10902     CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
   10903     {
   10904       renderPass = renderPass_;
   10905       return *this;
   10906     }
   10907 
   10908     CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
   10909     {
   10910       subpass = subpass_;
   10911       return *this;
   10912     }
   10913 
   10914     CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
   10915     {
   10916       framebuffer = framebuffer_;
   10917       return *this;
   10918     }
   10919 
   10920     CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
   10921     {
   10922       occlusionQueryEnable = occlusionQueryEnable_;
   10923       return *this;
   10924     }
   10925 
   10926     CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
   10927     {
   10928       queryFlags = queryFlags_;
   10929       return *this;
   10930     }
   10931 
   10932     CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
   10933     {
   10934       pipelineStatistics = pipelineStatistics_;
   10935       return *this;
   10936     }
   10937 
   10938     operator const VkCommandBufferInheritanceInfo&() const
   10939     {
   10940       return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
   10941     }
   10942 
   10943     bool operator==( CommandBufferInheritanceInfo const& rhs ) const
   10944     {
   10945       return ( sType == rhs.sType )
   10946           && ( pNext == rhs.pNext )
   10947           && ( renderPass == rhs.renderPass )
   10948           && ( subpass == rhs.subpass )
   10949           && ( framebuffer == rhs.framebuffer )
   10950           && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
   10951           && ( queryFlags == rhs.queryFlags )
   10952           && ( pipelineStatistics == rhs.pipelineStatistics );
   10953     }
   10954 
   10955     bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
   10956     {
   10957       return !operator==( rhs );
   10958     }
   10959 
   10960   private:
   10961     StructureType sType;
   10962 
   10963   public:
   10964     const void* pNext;
   10965     RenderPass renderPass;
   10966     uint32_t subpass;
   10967     Framebuffer framebuffer;
   10968     Bool32 occlusionQueryEnable;
   10969     QueryControlFlags queryFlags;
   10970     QueryPipelineStatisticFlags pipelineStatistics;
   10971   };
   10972   static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
   10973 
   10974   struct CommandBufferBeginInfo
   10975   {
   10976     CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
   10977       : sType( StructureType::eCommandBufferBeginInfo )
   10978       , pNext( nullptr )
   10979       , flags( flags_ )
   10980       , pInheritanceInfo( pInheritanceInfo_ )
   10981     {
   10982     }
   10983 
   10984     CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
   10985     {
   10986       memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
   10987     }
   10988 
   10989     CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
   10990     {
   10991       memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
   10992       return *this;
   10993     }
   10994 
   10995     CommandBufferBeginInfo& setSType( StructureType sType_ )
   10996     {
   10997       sType = sType_;
   10998       return *this;
   10999     }
   11000 
   11001     CommandBufferBeginInfo& setPNext( const void* pNext_ )
   11002     {
   11003       pNext = pNext_;
   11004       return *this;
   11005     }
   11006 
   11007     CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
   11008     {
   11009       flags = flags_;
   11010       return *this;
   11011     }
   11012 
   11013     CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
   11014     {
   11015       pInheritanceInfo = pInheritanceInfo_;
   11016       return *this;
   11017     }
   11018 
   11019     operator const VkCommandBufferBeginInfo&() const
   11020     {
   11021       return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
   11022     }
   11023 
   11024     bool operator==( CommandBufferBeginInfo const& rhs ) const
   11025     {
   11026       return ( sType == rhs.sType )
   11027           && ( pNext == rhs.pNext )
   11028           && ( flags == rhs.flags )
   11029           && ( pInheritanceInfo == rhs.pInheritanceInfo );
   11030     }
   11031 
   11032     bool operator!=( CommandBufferBeginInfo const& rhs ) const
   11033     {
   11034       return !operator==( rhs );
   11035     }
   11036 
   11037   private:
   11038     StructureType sType;
   11039 
   11040   public:
   11041     const void* pNext;
   11042     CommandBufferUsageFlags flags;
   11043     const CommandBufferInheritanceInfo* pInheritanceInfo;
   11044   };
   11045   static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
   11046 
   11047   struct QueryPoolCreateInfo
   11048   {
   11049     QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
   11050       : sType( StructureType::eQueryPoolCreateInfo )
   11051       , pNext( nullptr )
   11052       , flags( flags_ )
   11053       , queryType( queryType_ )
   11054       , queryCount( queryCount_ )
   11055       , pipelineStatistics( pipelineStatistics_ )
   11056     {
   11057     }
   11058 
   11059     QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
   11060     {
   11061       memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
   11062     }
   11063 
   11064     QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
   11065     {
   11066       memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
   11067       return *this;
   11068     }
   11069 
   11070     QueryPoolCreateInfo& setSType( StructureType sType_ )
   11071     {
   11072       sType = sType_;
   11073       return *this;
   11074     }
   11075 
   11076     QueryPoolCreateInfo& setPNext( const void* pNext_ )
   11077     {
   11078       pNext = pNext_;
   11079       return *this;
   11080     }
   11081 
   11082     QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
   11083     {
   11084       flags = flags_;
   11085       return *this;
   11086     }
   11087 
   11088     QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
   11089     {
   11090       queryType = queryType_;
   11091       return *this;
   11092     }
   11093 
   11094     QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
   11095     {
   11096       queryCount = queryCount_;
   11097       return *this;
   11098     }
   11099 
   11100     QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
   11101     {
   11102       pipelineStatistics = pipelineStatistics_;
   11103       return *this;
   11104     }
   11105 
   11106     operator const VkQueryPoolCreateInfo&() const
   11107     {
   11108       return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
   11109     }
   11110 
   11111     bool operator==( QueryPoolCreateInfo const& rhs ) const
   11112     {
   11113       return ( sType == rhs.sType )
   11114           && ( pNext == rhs.pNext )
   11115           && ( flags == rhs.flags )
   11116           && ( queryType == rhs.queryType )
   11117           && ( queryCount == rhs.queryCount )
   11118           && ( pipelineStatistics == rhs.pipelineStatistics );
   11119     }
   11120 
   11121     bool operator!=( QueryPoolCreateInfo const& rhs ) const
   11122     {
   11123       return !operator==( rhs );
   11124     }
   11125 
   11126   private:
   11127     StructureType sType;
   11128 
   11129   public:
   11130     const void* pNext;
   11131     QueryPoolCreateFlags flags;
   11132     QueryType queryType;
   11133     uint32_t queryCount;
   11134     QueryPipelineStatisticFlags pipelineStatistics;
   11135   };
   11136   static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
   11137 
   11138   enum class ImageAspectFlagBits
   11139   {
   11140     eColor = VK_IMAGE_ASPECT_COLOR_BIT,
   11141     eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
   11142     eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
   11143     eMetadata = VK_IMAGE_ASPECT_METADATA_BIT
   11144   };
   11145 
   11146   using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
   11147 
   11148   inline ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
   11149   {
   11150     return ImageAspectFlags( bit0 ) | bit1;
   11151   }
   11152 
   11153   struct ImageSubresource
   11154   {
   11155     ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 )
   11156       : aspectMask( aspectMask_ )
   11157       , mipLevel( mipLevel_ )
   11158       , arrayLayer( arrayLayer_ )
   11159     {
   11160     }
   11161 
   11162     ImageSubresource( VkImageSubresource const & rhs )
   11163     {
   11164       memcpy( this, &rhs, sizeof(ImageSubresource) );
   11165     }
   11166 
   11167     ImageSubresource& operator=( VkImageSubresource const & rhs )
   11168     {
   11169       memcpy( this, &rhs, sizeof(ImageSubresource) );
   11170       return *this;
   11171     }
   11172 
   11173     ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
   11174     {
   11175       aspectMask = aspectMask_;
   11176       return *this;
   11177     }
   11178 
   11179     ImageSubresource& setMipLevel( uint32_t mipLevel_ )
   11180     {
   11181       mipLevel = mipLevel_;
   11182       return *this;
   11183     }
   11184 
   11185     ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
   11186     {
   11187       arrayLayer = arrayLayer_;
   11188       return *this;
   11189     }
   11190 
   11191     operator const VkImageSubresource&() const
   11192     {
   11193       return *reinterpret_cast<const VkImageSubresource*>(this);
   11194     }
   11195 
   11196     bool operator==( ImageSubresource const& rhs ) const
   11197     {
   11198       return ( aspectMask == rhs.aspectMask )
   11199           && ( mipLevel == rhs.mipLevel )
   11200           && ( arrayLayer == rhs.arrayLayer );
   11201     }
   11202 
   11203     bool operator!=( ImageSubresource const& rhs ) const
   11204     {
   11205       return !operator==( rhs );
   11206     }
   11207 
   11208     ImageAspectFlags aspectMask;
   11209     uint32_t mipLevel;
   11210     uint32_t arrayLayer;
   11211   };
   11212   static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
   11213 
   11214   struct ImageSubresourceLayers
   11215   {
   11216     ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
   11217       : aspectMask( aspectMask_ )
   11218       , mipLevel( mipLevel_ )
   11219       , baseArrayLayer( baseArrayLayer_ )
   11220       , layerCount( layerCount_ )
   11221     {
   11222     }
   11223 
   11224     ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
   11225     {
   11226       memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
   11227     }
   11228 
   11229     ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
   11230     {
   11231       memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
   11232       return *this;
   11233     }
   11234 
   11235     ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
   11236     {
   11237       aspectMask = aspectMask_;
   11238       return *this;
   11239     }
   11240 
   11241     ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
   11242     {
   11243       mipLevel = mipLevel_;
   11244       return *this;
   11245     }
   11246 
   11247     ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
   11248     {
   11249       baseArrayLayer = baseArrayLayer_;
   11250       return *this;
   11251     }
   11252 
   11253     ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
   11254     {
   11255       layerCount = layerCount_;
   11256       return *this;
   11257     }
   11258 
   11259     operator const VkImageSubresourceLayers&() const
   11260     {
   11261       return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
   11262     }
   11263 
   11264     bool operator==( ImageSubresourceLayers const& rhs ) const
   11265     {
   11266       return ( aspectMask == rhs.aspectMask )
   11267           && ( mipLevel == rhs.mipLevel )
   11268           && ( baseArrayLayer == rhs.baseArrayLayer )
   11269           && ( layerCount == rhs.layerCount );
   11270     }
   11271 
   11272     bool operator!=( ImageSubresourceLayers const& rhs ) const
   11273     {
   11274       return !operator==( rhs );
   11275     }
   11276 
   11277     ImageAspectFlags aspectMask;
   11278     uint32_t mipLevel;
   11279     uint32_t baseArrayLayer;
   11280     uint32_t layerCount;
   11281   };
   11282   static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
   11283 
   11284   struct ImageSubresourceRange
   11285   {
   11286     ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
   11287       : aspectMask( aspectMask_ )
   11288       , baseMipLevel( baseMipLevel_ )
   11289       , levelCount( levelCount_ )
   11290       , baseArrayLayer( baseArrayLayer_ )
   11291       , layerCount( layerCount_ )
   11292     {
   11293     }
   11294 
   11295     ImageSubresourceRange( VkImageSubresourceRange const & rhs )
   11296     {
   11297       memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
   11298     }
   11299 
   11300     ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
   11301     {
   11302       memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
   11303       return *this;
   11304     }
   11305 
   11306     ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
   11307     {
   11308       aspectMask = aspectMask_;
   11309       return *this;
   11310     }
   11311 
   11312     ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
   11313     {
   11314       baseMipLevel = baseMipLevel_;
   11315       return *this;
   11316     }
   11317 
   11318     ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
   11319     {
   11320       levelCount = levelCount_;
   11321       return *this;
   11322     }
   11323 
   11324     ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
   11325     {
   11326       baseArrayLayer = baseArrayLayer_;
   11327       return *this;
   11328     }
   11329 
   11330     ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
   11331     {
   11332       layerCount = layerCount_;
   11333       return *this;
   11334     }
   11335 
   11336     operator const VkImageSubresourceRange&() const
   11337     {
   11338       return *reinterpret_cast<const VkImageSubresourceRange*>(this);
   11339     }
   11340 
   11341     bool operator==( ImageSubresourceRange const& rhs ) const
   11342     {
   11343       return ( aspectMask == rhs.aspectMask )
   11344           && ( baseMipLevel == rhs.baseMipLevel )
   11345           && ( levelCount == rhs.levelCount )
   11346           && ( baseArrayLayer == rhs.baseArrayLayer )
   11347           && ( layerCount == rhs.layerCount );
   11348     }
   11349 
   11350     bool operator!=( ImageSubresourceRange const& rhs ) const
   11351     {
   11352       return !operator==( rhs );
   11353     }
   11354 
   11355     ImageAspectFlags aspectMask;
   11356     uint32_t baseMipLevel;
   11357     uint32_t levelCount;
   11358     uint32_t baseArrayLayer;
   11359     uint32_t layerCount;
   11360   };
   11361   static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
   11362 
   11363   struct ImageMemoryBarrier
   11364   {
   11365     ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
   11366       : sType( StructureType::eImageMemoryBarrier )
   11367       , pNext( nullptr )
   11368       , srcAccessMask( srcAccessMask_ )
   11369       , dstAccessMask( dstAccessMask_ )
   11370       , oldLayout( oldLayout_ )
   11371       , newLayout( newLayout_ )
   11372       , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
   11373       , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
   11374       , image( image_ )
   11375       , subresourceRange( subresourceRange_ )
   11376     {
   11377     }
   11378 
   11379     ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
   11380     {
   11381       memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
   11382     }
   11383 
   11384     ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
   11385     {
   11386       memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
   11387       return *this;
   11388     }
   11389 
   11390     ImageMemoryBarrier& setSType( StructureType sType_ )
   11391     {
   11392       sType = sType_;
   11393       return *this;
   11394     }
   11395 
   11396     ImageMemoryBarrier& setPNext( const void* pNext_ )
   11397     {
   11398       pNext = pNext_;
   11399       return *this;
   11400     }
   11401 
   11402     ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
   11403     {
   11404       srcAccessMask = srcAccessMask_;
   11405       return *this;
   11406     }
   11407 
   11408     ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
   11409     {
   11410       dstAccessMask = dstAccessMask_;
   11411       return *this;
   11412     }
   11413 
   11414     ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
   11415     {
   11416       oldLayout = oldLayout_;
   11417       return *this;
   11418     }
   11419 
   11420     ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
   11421     {
   11422       newLayout = newLayout_;
   11423       return *this;
   11424     }
   11425 
   11426     ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
   11427     {
   11428       srcQueueFamilyIndex = srcQueueFamilyIndex_;
   11429       return *this;
   11430     }
   11431 
   11432     ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
   11433     {
   11434       dstQueueFamilyIndex = dstQueueFamilyIndex_;
   11435       return *this;
   11436     }
   11437 
   11438     ImageMemoryBarrier& setImage( Image image_ )
   11439     {
   11440       image = image_;
   11441       return *this;
   11442     }
   11443 
   11444     ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
   11445     {
   11446       subresourceRange = subresourceRange_;
   11447       return *this;
   11448     }
   11449 
   11450     operator const VkImageMemoryBarrier&() const
   11451     {
   11452       return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
   11453     }
   11454 
   11455     bool operator==( ImageMemoryBarrier const& rhs ) const
   11456     {
   11457       return ( sType == rhs.sType )
   11458           && ( pNext == rhs.pNext )
   11459           && ( srcAccessMask == rhs.srcAccessMask )
   11460           && ( dstAccessMask == rhs.dstAccessMask )
   11461           && ( oldLayout == rhs.oldLayout )
   11462           && ( newLayout == rhs.newLayout )
   11463           && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
   11464           && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
   11465           && ( image == rhs.image )
   11466           && ( subresourceRange == rhs.subresourceRange );
   11467     }
   11468 
   11469     bool operator!=( ImageMemoryBarrier const& rhs ) const
   11470     {
   11471       return !operator==( rhs );
   11472     }
   11473 
   11474   private:
   11475     StructureType sType;
   11476 
   11477   public:
   11478     const void* pNext;
   11479     AccessFlags srcAccessMask;
   11480     AccessFlags dstAccessMask;
   11481     ImageLayout oldLayout;
   11482     ImageLayout newLayout;
   11483     uint32_t srcQueueFamilyIndex;
   11484     uint32_t dstQueueFamilyIndex;
   11485     Image image;
   11486     ImageSubresourceRange subresourceRange;
   11487   };
   11488   static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
   11489 
   11490   struct ImageViewCreateInfo
   11491   {
   11492     ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
   11493       : sType( StructureType::eImageViewCreateInfo )
   11494       , pNext( nullptr )
   11495       , flags( flags_ )
   11496       , image( image_ )
   11497       , viewType( viewType_ )
   11498       , format( format_ )
   11499       , components( components_ )
   11500       , subresourceRange( subresourceRange_ )
   11501     {
   11502     }
   11503 
   11504     ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
   11505     {
   11506       memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
   11507     }
   11508 
   11509     ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
   11510     {
   11511       memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
   11512       return *this;
   11513     }
   11514 
   11515     ImageViewCreateInfo& setSType( StructureType sType_ )
   11516     {
   11517       sType = sType_;
   11518       return *this;
   11519     }
   11520 
   11521     ImageViewCreateInfo& setPNext( const void* pNext_ )
   11522     {
   11523       pNext = pNext_;
   11524       return *this;
   11525     }
   11526 
   11527     ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
   11528     {
   11529       flags = flags_;
   11530       return *this;
   11531     }
   11532 
   11533     ImageViewCreateInfo& setImage( Image image_ )
   11534     {
   11535       image = image_;
   11536       return *this;
   11537     }
   11538 
   11539     ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
   11540     {
   11541       viewType = viewType_;
   11542       return *this;
   11543     }
   11544 
   11545     ImageViewCreateInfo& setFormat( Format format_ )
   11546     {
   11547       format = format_;
   11548       return *this;
   11549     }
   11550 
   11551     ImageViewCreateInfo& setComponents( ComponentMapping components_ )
   11552     {
   11553       components = components_;
   11554       return *this;
   11555     }
   11556 
   11557     ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
   11558     {
   11559       subresourceRange = subresourceRange_;
   11560       return *this;
   11561     }
   11562 
   11563     operator const VkImageViewCreateInfo&() const
   11564     {
   11565       return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
   11566     }
   11567 
   11568     bool operator==( ImageViewCreateInfo const& rhs ) const
   11569     {
   11570       return ( sType == rhs.sType )
   11571           && ( pNext == rhs.pNext )
   11572           && ( flags == rhs.flags )
   11573           && ( image == rhs.image )
   11574           && ( viewType == rhs.viewType )
   11575           && ( format == rhs.format )
   11576           && ( components == rhs.components )
   11577           && ( subresourceRange == rhs.subresourceRange );
   11578     }
   11579 
   11580     bool operator!=( ImageViewCreateInfo const& rhs ) const
   11581     {
   11582       return !operator==( rhs );
   11583     }
   11584 
   11585   private:
   11586     StructureType sType;
   11587 
   11588   public:
   11589     const void* pNext;
   11590     ImageViewCreateFlags flags;
   11591     Image image;
   11592     ImageViewType viewType;
   11593     Format format;
   11594     ComponentMapping components;
   11595     ImageSubresourceRange subresourceRange;
   11596   };
   11597   static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
   11598 
   11599   struct ImageCopy
   11600   {
   11601     ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
   11602       : srcSubresource( srcSubresource_ )
   11603       , srcOffset( srcOffset_ )
   11604       , dstSubresource( dstSubresource_ )
   11605       , dstOffset( dstOffset_ )
   11606       , extent( extent_ )
   11607     {
   11608     }
   11609 
   11610     ImageCopy( VkImageCopy const & rhs )
   11611     {
   11612       memcpy( this, &rhs, sizeof(ImageCopy) );
   11613     }
   11614 
   11615     ImageCopy& operator=( VkImageCopy const & rhs )
   11616     {
   11617       memcpy( this, &rhs, sizeof(ImageCopy) );
   11618       return *this;
   11619     }
   11620 
   11621     ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
   11622     {
   11623       srcSubresource = srcSubresource_;
   11624       return *this;
   11625     }
   11626 
   11627     ImageCopy& setSrcOffset( Offset3D srcOffset_ )
   11628     {
   11629       srcOffset = srcOffset_;
   11630       return *this;
   11631     }
   11632 
   11633     ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
   11634     {
   11635       dstSubresource = dstSubresource_;
   11636       return *this;
   11637     }
   11638 
   11639     ImageCopy& setDstOffset( Offset3D dstOffset_ )
   11640     {
   11641       dstOffset = dstOffset_;
   11642       return *this;
   11643     }
   11644 
   11645     ImageCopy& setExtent( Extent3D extent_ )
   11646     {
   11647       extent = extent_;
   11648       return *this;
   11649     }
   11650 
   11651     operator const VkImageCopy&() const
   11652     {
   11653       return *reinterpret_cast<const VkImageCopy*>(this);
   11654     }
   11655 
   11656     bool operator==( ImageCopy const& rhs ) const
   11657     {
   11658       return ( srcSubresource == rhs.srcSubresource )
   11659           && ( srcOffset == rhs.srcOffset )
   11660           && ( dstSubresource == rhs.dstSubresource )
   11661           && ( dstOffset == rhs.dstOffset )
   11662           && ( extent == rhs.extent );
   11663     }
   11664 
   11665     bool operator!=( ImageCopy const& rhs ) const
   11666     {
   11667       return !operator==( rhs );
   11668     }
   11669 
   11670     ImageSubresourceLayers srcSubresource;
   11671     Offset3D srcOffset;
   11672     ImageSubresourceLayers dstSubresource;
   11673     Offset3D dstOffset;
   11674     Extent3D extent;
   11675   };
   11676   static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
   11677 
   11678   struct ImageBlit
   11679   {
   11680     ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
   11681       : srcSubresource( srcSubresource_ )
   11682       , dstSubresource( dstSubresource_ )
   11683     {
   11684       memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
   11685       memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
   11686     }
   11687 
   11688     ImageBlit( VkImageBlit const & rhs )
   11689     {
   11690       memcpy( this, &rhs, sizeof(ImageBlit) );
   11691     }
   11692 
   11693     ImageBlit& operator=( VkImageBlit const & rhs )
   11694     {
   11695       memcpy( this, &rhs, sizeof(ImageBlit) );
   11696       return *this;
   11697     }
   11698 
   11699     ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
   11700     {
   11701       srcSubresource = srcSubresource_;
   11702       return *this;
   11703     }
   11704 
   11705     ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
   11706     {
   11707       memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
   11708       return *this;
   11709     }
   11710 
   11711     ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
   11712     {
   11713       dstSubresource = dstSubresource_;
   11714       return *this;
   11715     }
   11716 
   11717     ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
   11718     {
   11719       memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
   11720       return *this;
   11721     }
   11722 
   11723     operator const VkImageBlit&() const
   11724     {
   11725       return *reinterpret_cast<const VkImageBlit*>(this);
   11726     }
   11727 
   11728     bool operator==( ImageBlit const& rhs ) const
   11729     {
   11730       return ( srcSubresource == rhs.srcSubresource )
   11731           && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
   11732           && ( dstSubresource == rhs.dstSubresource )
   11733           && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
   11734     }
   11735 
   11736     bool operator!=( ImageBlit const& rhs ) const
   11737     {
   11738       return !operator==( rhs );
   11739     }
   11740 
   11741     ImageSubresourceLayers srcSubresource;
   11742     Offset3D srcOffsets[2];
   11743     ImageSubresourceLayers dstSubresource;
   11744     Offset3D dstOffsets[2];
   11745   };
   11746   static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
   11747 
   11748   struct BufferImageCopy
   11749   {
   11750     BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() )
   11751       : bufferOffset( bufferOffset_ )
   11752       , bufferRowLength( bufferRowLength_ )
   11753       , bufferImageHeight( bufferImageHeight_ )
   11754       , imageSubresource( imageSubresource_ )
   11755       , imageOffset( imageOffset_ )
   11756       , imageExtent( imageExtent_ )
   11757     {
   11758     }
   11759 
   11760     BufferImageCopy( VkBufferImageCopy const & rhs )
   11761     {
   11762       memcpy( this, &rhs, sizeof(BufferImageCopy) );
   11763     }
   11764 
   11765     BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
   11766     {
   11767       memcpy( this, &rhs, sizeof(BufferImageCopy) );
   11768       return *this;
   11769     }
   11770 
   11771     BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
   11772     {
   11773       bufferOffset = bufferOffset_;
   11774       return *this;
   11775     }
   11776 
   11777     BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
   11778     {
   11779       bufferRowLength = bufferRowLength_;
   11780       return *this;
   11781     }
   11782 
   11783     BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
   11784     {
   11785       bufferImageHeight = bufferImageHeight_;
   11786       return *this;
   11787     }
   11788 
   11789     BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
   11790     {
   11791       imageSubresource = imageSubresource_;
   11792       return *this;
   11793     }
   11794 
   11795     BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
   11796     {
   11797       imageOffset = imageOffset_;
   11798       return *this;
   11799     }
   11800 
   11801     BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
   11802     {
   11803       imageExtent = imageExtent_;
   11804       return *this;
   11805     }
   11806 
   11807     operator const VkBufferImageCopy&() const
   11808     {
   11809       return *reinterpret_cast<const VkBufferImageCopy*>(this);
   11810     }
   11811 
   11812     bool operator==( BufferImageCopy const& rhs ) const
   11813     {
   11814       return ( bufferOffset == rhs.bufferOffset )
   11815           && ( bufferRowLength == rhs.bufferRowLength )
   11816           && ( bufferImageHeight == rhs.bufferImageHeight )
   11817           && ( imageSubresource == rhs.imageSubresource )
   11818           && ( imageOffset == rhs.imageOffset )
   11819           && ( imageExtent == rhs.imageExtent );
   11820     }
   11821 
   11822     bool operator!=( BufferImageCopy const& rhs ) const
   11823     {
   11824       return !operator==( rhs );
   11825     }
   11826 
   11827     DeviceSize bufferOffset;
   11828     uint32_t bufferRowLength;
   11829     uint32_t bufferImageHeight;
   11830     ImageSubresourceLayers imageSubresource;
   11831     Offset3D imageOffset;
   11832     Extent3D imageExtent;
   11833   };
   11834   static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
   11835 
   11836   struct ImageResolve
   11837   {
   11838     ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
   11839       : srcSubresource( srcSubresource_ )
   11840       , srcOffset( srcOffset_ )
   11841       , dstSubresource( dstSubresource_ )
   11842       , dstOffset( dstOffset_ )
   11843       , extent( extent_ )
   11844     {
   11845     }
   11846 
   11847     ImageResolve( VkImageResolve const & rhs )
   11848     {
   11849       memcpy( this, &rhs, sizeof(ImageResolve) );
   11850     }
   11851 
   11852     ImageResolve& operator=( VkImageResolve const & rhs )
   11853     {
   11854       memcpy( this, &rhs, sizeof(ImageResolve) );
   11855       return *this;
   11856     }
   11857 
   11858     ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
   11859     {
   11860       srcSubresource = srcSubresource_;
   11861       return *this;
   11862     }
   11863 
   11864     ImageResolve& setSrcOffset( Offset3D srcOffset_ )
   11865     {
   11866       srcOffset = srcOffset_;
   11867       return *this;
   11868     }
   11869 
   11870     ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
   11871     {
   11872       dstSubresource = dstSubresource_;
   11873       return *this;
   11874     }
   11875 
   11876     ImageResolve& setDstOffset( Offset3D dstOffset_ )
   11877     {
   11878       dstOffset = dstOffset_;
   11879       return *this;
   11880     }
   11881 
   11882     ImageResolve& setExtent( Extent3D extent_ )
   11883     {
   11884       extent = extent_;
   11885       return *this;
   11886     }
   11887 
   11888     operator const VkImageResolve&() const
   11889     {
   11890       return *reinterpret_cast<const VkImageResolve*>(this);
   11891     }
   11892 
   11893     bool operator==( ImageResolve const& rhs ) const
   11894     {
   11895       return ( srcSubresource == rhs.srcSubresource )
   11896           && ( srcOffset == rhs.srcOffset )
   11897           && ( dstSubresource == rhs.dstSubresource )
   11898           && ( dstOffset == rhs.dstOffset )
   11899           && ( extent == rhs.extent );
   11900     }
   11901 
   11902     bool operator!=( ImageResolve const& rhs ) const
   11903     {
   11904       return !operator==( rhs );
   11905     }
   11906 
   11907     ImageSubresourceLayers srcSubresource;
   11908     Offset3D srcOffset;
   11909     ImageSubresourceLayers dstSubresource;
   11910     Offset3D dstOffset;
   11911     Extent3D extent;
   11912   };
   11913   static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
   11914 
   11915   struct ClearAttachment
   11916   {
   11917     ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() )
   11918       : aspectMask( aspectMask_ )
   11919       , colorAttachment( colorAttachment_ )
   11920       , clearValue( clearValue_ )
   11921     {
   11922     }
   11923 
   11924     ClearAttachment( VkClearAttachment const & rhs )
   11925     {
   11926       memcpy( this, &rhs, sizeof(ClearAttachment) );
   11927     }
   11928 
   11929     ClearAttachment& operator=( VkClearAttachment const & rhs )
   11930     {
   11931       memcpy( this, &rhs, sizeof(ClearAttachment) );
   11932       return *this;
   11933     }
   11934 
   11935     ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
   11936     {
   11937       aspectMask = aspectMask_;
   11938       return *this;
   11939     }
   11940 
   11941     ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
   11942     {
   11943       colorAttachment = colorAttachment_;
   11944       return *this;
   11945     }
   11946 
   11947     ClearAttachment& setClearValue( ClearValue clearValue_ )
   11948     {
   11949       clearValue = clearValue_;
   11950       return *this;
   11951     }
   11952 
   11953     operator const VkClearAttachment&() const
   11954     {
   11955       return *reinterpret_cast<const VkClearAttachment*>(this);
   11956     }
   11957 
   11958     ImageAspectFlags aspectMask;
   11959     uint32_t colorAttachment;
   11960     ClearValue clearValue;
   11961   };
   11962   static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
   11963 
   11964   enum class SparseImageFormatFlagBits
   11965   {
   11966     eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
   11967     eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
   11968     eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
   11969   };
   11970 
   11971   using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
   11972 
   11973   inline SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
   11974   {
   11975     return SparseImageFormatFlags( bit0 ) | bit1;
   11976   }
   11977 
   11978   struct SparseImageFormatProperties
   11979   {
   11980     operator const VkSparseImageFormatProperties&() const
   11981     {
   11982       return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
   11983     }
   11984 
   11985     bool operator==( SparseImageFormatProperties const& rhs ) const
   11986     {
   11987       return ( aspectMask == rhs.aspectMask )
   11988           && ( imageGranularity == rhs.imageGranularity )
   11989           && ( flags == rhs.flags );
   11990     }
   11991 
   11992     bool operator!=( SparseImageFormatProperties const& rhs ) const
   11993     {
   11994       return !operator==( rhs );
   11995     }
   11996 
   11997     ImageAspectFlags aspectMask;
   11998     Extent3D imageGranularity;
   11999     SparseImageFormatFlags flags;
   12000   };
   12001   static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
   12002 
   12003   struct SparseImageMemoryRequirements
   12004   {
   12005     operator const VkSparseImageMemoryRequirements&() const
   12006     {
   12007       return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
   12008     }
   12009 
   12010     bool operator==( SparseImageMemoryRequirements const& rhs ) const
   12011     {
   12012       return ( formatProperties == rhs.formatProperties )
   12013           && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
   12014           && ( imageMipTailSize == rhs.imageMipTailSize )
   12015           && ( imageMipTailOffset == rhs.imageMipTailOffset )
   12016           && ( imageMipTailStride == rhs.imageMipTailStride );
   12017     }
   12018 
   12019     bool operator!=( SparseImageMemoryRequirements const& rhs ) const
   12020     {
   12021       return !operator==( rhs );
   12022     }
   12023 
   12024     SparseImageFormatProperties formatProperties;
   12025     uint32_t imageMipTailFirstLod;
   12026     DeviceSize imageMipTailSize;
   12027     DeviceSize imageMipTailOffset;
   12028     DeviceSize imageMipTailStride;
   12029   };
   12030   static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
   12031 
   12032   enum class SparseMemoryBindFlagBits
   12033   {
   12034     eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
   12035   };
   12036 
   12037   using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
   12038 
   12039   inline SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
   12040   {
   12041     return SparseMemoryBindFlags( bit0 ) | bit1;
   12042   }
   12043 
   12044   struct SparseMemoryBind
   12045   {
   12046     SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
   12047       : resourceOffset( resourceOffset_ )
   12048       , size( size_ )
   12049       , memory( memory_ )
   12050       , memoryOffset( memoryOffset_ )
   12051       , flags( flags_ )
   12052     {
   12053     }
   12054 
   12055     SparseMemoryBind( VkSparseMemoryBind const & rhs )
   12056     {
   12057       memcpy( this, &rhs, sizeof(SparseMemoryBind) );
   12058     }
   12059 
   12060     SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
   12061     {
   12062       memcpy( this, &rhs, sizeof(SparseMemoryBind) );
   12063       return *this;
   12064     }
   12065 
   12066     SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
   12067     {
   12068       resourceOffset = resourceOffset_;
   12069       return *this;
   12070     }
   12071 
   12072     SparseMemoryBind& setSize( DeviceSize size_ )
   12073     {
   12074       size = size_;
   12075       return *this;
   12076     }
   12077 
   12078     SparseMemoryBind& setMemory( DeviceMemory memory_ )
   12079     {
   12080       memory = memory_;
   12081       return *this;
   12082     }
   12083 
   12084     SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
   12085     {
   12086       memoryOffset = memoryOffset_;
   12087       return *this;
   12088     }
   12089 
   12090     SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
   12091     {
   12092       flags = flags_;
   12093       return *this;
   12094     }
   12095 
   12096     operator const VkSparseMemoryBind&() const
   12097     {
   12098       return *reinterpret_cast<const VkSparseMemoryBind*>(this);
   12099     }
   12100 
   12101     bool operator==( SparseMemoryBind const& rhs ) const
   12102     {
   12103       return ( resourceOffset == rhs.resourceOffset )
   12104           && ( size == rhs.size )
   12105           && ( memory == rhs.memory )
   12106           && ( memoryOffset == rhs.memoryOffset )
   12107           && ( flags == rhs.flags );
   12108     }
   12109 
   12110     bool operator!=( SparseMemoryBind const& rhs ) const
   12111     {
   12112       return !operator==( rhs );
   12113     }
   12114 
   12115     DeviceSize resourceOffset;
   12116     DeviceSize size;
   12117     DeviceMemory memory;
   12118     DeviceSize memoryOffset;
   12119     SparseMemoryBindFlags flags;
   12120   };
   12121   static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
   12122 
   12123   struct SparseImageMemoryBind
   12124   {
   12125     SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
   12126       : subresource( subresource_ )
   12127       , offset( offset_ )
   12128       , extent( extent_ )
   12129       , memory( memory_ )
   12130       , memoryOffset( memoryOffset_ )
   12131       , flags( flags_ )
   12132     {
   12133     }
   12134 
   12135     SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
   12136     {
   12137       memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
   12138     }
   12139 
   12140     SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
   12141     {
   12142       memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
   12143       return *this;
   12144     }
   12145 
   12146     SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
   12147     {
   12148       subresource = subresource_;
   12149       return *this;
   12150     }
   12151 
   12152     SparseImageMemoryBind& setOffset( Offset3D offset_ )
   12153     {
   12154       offset = offset_;
   12155       return *this;
   12156     }
   12157 
   12158     SparseImageMemoryBind& setExtent( Extent3D extent_ )
   12159     {
   12160       extent = extent_;
   12161       return *this;
   12162     }
   12163 
   12164     SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
   12165     {
   12166       memory = memory_;
   12167       return *this;
   12168     }
   12169 
   12170     SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
   12171     {
   12172       memoryOffset = memoryOffset_;
   12173       return *this;
   12174     }
   12175 
   12176     SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
   12177     {
   12178       flags = flags_;
   12179       return *this;
   12180     }
   12181 
   12182     operator const VkSparseImageMemoryBind&() const
   12183     {
   12184       return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
   12185     }
   12186 
   12187     bool operator==( SparseImageMemoryBind const& rhs ) const
   12188     {
   12189       return ( subresource == rhs.subresource )
   12190           && ( offset == rhs.offset )
   12191           && ( extent == rhs.extent )
   12192           && ( memory == rhs.memory )
   12193           && ( memoryOffset == rhs.memoryOffset )
   12194           && ( flags == rhs.flags );
   12195     }
   12196 
   12197     bool operator!=( SparseImageMemoryBind const& rhs ) const
   12198     {
   12199       return !operator==( rhs );
   12200     }
   12201 
   12202     ImageSubresource subresource;
   12203     Offset3D offset;
   12204     Extent3D extent;
   12205     DeviceMemory memory;
   12206     DeviceSize memoryOffset;
   12207     SparseMemoryBindFlags flags;
   12208   };
   12209   static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
   12210 
   12211   struct SparseBufferMemoryBindInfo
   12212   {
   12213     SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
   12214       : buffer( buffer_ )
   12215       , bindCount( bindCount_ )
   12216       , pBinds( pBinds_ )
   12217     {
   12218     }
   12219 
   12220     SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
   12221     {
   12222       memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
   12223     }
   12224 
   12225     SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
   12226     {
   12227       memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
   12228       return *this;
   12229     }
   12230 
   12231     SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
   12232     {
   12233       buffer = buffer_;
   12234       return *this;
   12235     }
   12236 
   12237     SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
   12238     {
   12239       bindCount = bindCount_;
   12240       return *this;
   12241     }
   12242 
   12243     SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
   12244     {
   12245       pBinds = pBinds_;
   12246       return *this;
   12247     }
   12248 
   12249     operator const VkSparseBufferMemoryBindInfo&() const
   12250     {
   12251       return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
   12252     }
   12253 
   12254     bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
   12255     {
   12256       return ( buffer == rhs.buffer )
   12257           && ( bindCount == rhs.bindCount )
   12258           && ( pBinds == rhs.pBinds );
   12259     }
   12260 
   12261     bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
   12262     {
   12263       return !operator==( rhs );
   12264     }
   12265 
   12266     Buffer buffer;
   12267     uint32_t bindCount;
   12268     const SparseMemoryBind* pBinds;
   12269   };
   12270   static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
   12271 
   12272   struct SparseImageOpaqueMemoryBindInfo
   12273   {
   12274     SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
   12275       : image( image_ )
   12276       , bindCount( bindCount_ )
   12277       , pBinds( pBinds_ )
   12278     {
   12279     }
   12280 
   12281     SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
   12282     {
   12283       memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
   12284     }
   12285 
   12286     SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
   12287     {
   12288       memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
   12289       return *this;
   12290     }
   12291 
   12292     SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
   12293     {
   12294       image = image_;
   12295       return *this;
   12296     }
   12297 
   12298     SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
   12299     {
   12300       bindCount = bindCount_;
   12301       return *this;
   12302     }
   12303 
   12304     SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
   12305     {
   12306       pBinds = pBinds_;
   12307       return *this;
   12308     }
   12309 
   12310     operator const VkSparseImageOpaqueMemoryBindInfo&() const
   12311     {
   12312       return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
   12313     }
   12314 
   12315     bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
   12316     {
   12317       return ( image == rhs.image )
   12318           && ( bindCount == rhs.bindCount )
   12319           && ( pBinds == rhs.pBinds );
   12320     }
   12321 
   12322     bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
   12323     {
   12324       return !operator==( rhs );
   12325     }
   12326 
   12327     Image image;
   12328     uint32_t bindCount;
   12329     const SparseMemoryBind* pBinds;
   12330   };
   12331   static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
   12332 
   12333   struct SparseImageMemoryBindInfo
   12334   {
   12335     SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr )
   12336       : image( image_ )
   12337       , bindCount( bindCount_ )
   12338       , pBinds( pBinds_ )
   12339     {
   12340     }
   12341 
   12342     SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
   12343     {
   12344       memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
   12345     }
   12346 
   12347     SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
   12348     {
   12349       memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
   12350       return *this;
   12351     }
   12352 
   12353     SparseImageMemoryBindInfo& setImage( Image image_ )
   12354     {
   12355       image = image_;
   12356       return *this;
   12357     }
   12358 
   12359     SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
   12360     {
   12361       bindCount = bindCount_;
   12362       return *this;
   12363     }
   12364 
   12365     SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
   12366     {
   12367       pBinds = pBinds_;
   12368       return *this;
   12369     }
   12370 
   12371     operator const VkSparseImageMemoryBindInfo&() const
   12372     {
   12373       return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
   12374     }
   12375 
   12376     bool operator==( SparseImageMemoryBindInfo const& rhs ) const
   12377     {
   12378       return ( image == rhs.image )
   12379           && ( bindCount == rhs.bindCount )
   12380           && ( pBinds == rhs.pBinds );
   12381     }
   12382 
   12383     bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
   12384     {
   12385       return !operator==( rhs );
   12386     }
   12387 
   12388     Image image;
   12389     uint32_t bindCount;
   12390     const SparseImageMemoryBind* pBinds;
   12391   };
   12392   static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
   12393 
   12394   struct BindSparseInfo
   12395   {
   12396     BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
   12397       : sType( StructureType::eBindSparseInfo )
   12398       , pNext( nullptr )
   12399       , waitSemaphoreCount( waitSemaphoreCount_ )
   12400       , pWaitSemaphores( pWaitSemaphores_ )
   12401       , bufferBindCount( bufferBindCount_ )
   12402       , pBufferBinds( pBufferBinds_ )
   12403       , imageOpaqueBindCount( imageOpaqueBindCount_ )
   12404       , pImageOpaqueBinds( pImageOpaqueBinds_ )
   12405       , imageBindCount( imageBindCount_ )
   12406       , pImageBinds( pImageBinds_ )
   12407       , signalSemaphoreCount( signalSemaphoreCount_ )
   12408       , pSignalSemaphores( pSignalSemaphores_ )
   12409     {
   12410     }
   12411 
   12412     BindSparseInfo( VkBindSparseInfo const & rhs )
   12413     {
   12414       memcpy( this, &rhs, sizeof(BindSparseInfo) );
   12415     }
   12416 
   12417     BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
   12418     {
   12419       memcpy( this, &rhs, sizeof(BindSparseInfo) );
   12420       return *this;
   12421     }
   12422 
   12423     BindSparseInfo& setSType( StructureType sType_ )
   12424     {
   12425       sType = sType_;
   12426       return *this;
   12427     }
   12428 
   12429     BindSparseInfo& setPNext( const void* pNext_ )
   12430     {
   12431       pNext = pNext_;
   12432       return *this;
   12433     }
   12434 
   12435     BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
   12436     {
   12437       waitSemaphoreCount = waitSemaphoreCount_;
   12438       return *this;
   12439     }
   12440 
   12441     BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
   12442     {
   12443       pWaitSemaphores = pWaitSemaphores_;
   12444       return *this;
   12445     }
   12446 
   12447     BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
   12448     {
   12449       bufferBindCount = bufferBindCount_;
   12450       return *this;
   12451     }
   12452 
   12453     BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
   12454     {
   12455       pBufferBinds = pBufferBinds_;
   12456       return *this;
   12457     }
   12458 
   12459     BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
   12460     {
   12461       imageOpaqueBindCount = imageOpaqueBindCount_;
   12462       return *this;
   12463     }
   12464 
   12465     BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
   12466     {
   12467       pImageOpaqueBinds = pImageOpaqueBinds_;
   12468       return *this;
   12469     }
   12470 
   12471     BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
   12472     {
   12473       imageBindCount = imageBindCount_;
   12474       return *this;
   12475     }
   12476 
   12477     BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
   12478     {
   12479       pImageBinds = pImageBinds_;
   12480       return *this;
   12481     }
   12482 
   12483     BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
   12484     {
   12485       signalSemaphoreCount = signalSemaphoreCount_;
   12486       return *this;
   12487     }
   12488 
   12489     BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
   12490     {
   12491       pSignalSemaphores = pSignalSemaphores_;
   12492       return *this;
   12493     }
   12494 
   12495     operator const VkBindSparseInfo&() const
   12496     {
   12497       return *reinterpret_cast<const VkBindSparseInfo*>(this);
   12498     }
   12499 
   12500     bool operator==( BindSparseInfo const& rhs ) const
   12501     {
   12502       return ( sType == rhs.sType )
   12503           && ( pNext == rhs.pNext )
   12504           && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
   12505           && ( pWaitSemaphores == rhs.pWaitSemaphores )
   12506           && ( bufferBindCount == rhs.bufferBindCount )
   12507           && ( pBufferBinds == rhs.pBufferBinds )
   12508           && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
   12509           && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
   12510           && ( imageBindCount == rhs.imageBindCount )
   12511           && ( pImageBinds == rhs.pImageBinds )
   12512           && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
   12513           && ( pSignalSemaphores == rhs.pSignalSemaphores );
   12514     }
   12515 
   12516     bool operator!=( BindSparseInfo const& rhs ) const
   12517     {
   12518       return !operator==( rhs );
   12519     }
   12520 
   12521   private:
   12522     StructureType sType;
   12523 
   12524   public:
   12525     const void* pNext;
   12526     uint32_t waitSemaphoreCount;
   12527     const Semaphore* pWaitSemaphores;
   12528     uint32_t bufferBindCount;
   12529     const SparseBufferMemoryBindInfo* pBufferBinds;
   12530     uint32_t imageOpaqueBindCount;
   12531     const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
   12532     uint32_t imageBindCount;
   12533     const SparseImageMemoryBindInfo* pImageBinds;
   12534     uint32_t signalSemaphoreCount;
   12535     const Semaphore* pSignalSemaphores;
   12536   };
   12537   static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
   12538 
   12539   enum class PipelineStageFlagBits
   12540   {
   12541     eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
   12542     eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
   12543     eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
   12544     eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
   12545     eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
   12546     eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
   12547     eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
   12548     eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
   12549     eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
   12550     eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
   12551     eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
   12552     eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
   12553     eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
   12554     eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
   12555     eHost = VK_PIPELINE_STAGE_HOST_BIT,
   12556     eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
   12557     eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
   12558   };
   12559 
   12560   using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
   12561 
   12562   inline PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
   12563   {
   12564     return PipelineStageFlags( bit0 ) | bit1;
   12565   }
   12566 
   12567   enum class CommandPoolCreateFlagBits
   12568   {
   12569     eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
   12570     eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
   12571   };
   12572 
   12573   using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
   12574 
   12575   inline CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
   12576   {
   12577     return CommandPoolCreateFlags( bit0 ) | bit1;
   12578   }
   12579 
   12580   struct CommandPoolCreateInfo
   12581   {
   12582     CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 )
   12583       : sType( StructureType::eCommandPoolCreateInfo )
   12584       , pNext( nullptr )
   12585       , flags( flags_ )
   12586       , queueFamilyIndex( queueFamilyIndex_ )
   12587     {
   12588     }
   12589 
   12590     CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
   12591     {
   12592       memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
   12593     }
   12594 
   12595     CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
   12596     {
   12597       memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
   12598       return *this;
   12599     }
   12600 
   12601     CommandPoolCreateInfo& setSType( StructureType sType_ )
   12602     {
   12603       sType = sType_;
   12604       return *this;
   12605     }
   12606 
   12607     CommandPoolCreateInfo& setPNext( const void* pNext_ )
   12608     {
   12609       pNext = pNext_;
   12610       return *this;
   12611     }
   12612 
   12613     CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
   12614     {
   12615       flags = flags_;
   12616       return *this;
   12617     }
   12618 
   12619     CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
   12620     {
   12621       queueFamilyIndex = queueFamilyIndex_;
   12622       return *this;
   12623     }
   12624 
   12625     operator const VkCommandPoolCreateInfo&() const
   12626     {
   12627       return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
   12628     }
   12629 
   12630     bool operator==( CommandPoolCreateInfo const& rhs ) const
   12631     {
   12632       return ( sType == rhs.sType )
   12633           && ( pNext == rhs.pNext )
   12634           && ( flags == rhs.flags )
   12635           && ( queueFamilyIndex == rhs.queueFamilyIndex );
   12636     }
   12637 
   12638     bool operator!=( CommandPoolCreateInfo const& rhs ) const
   12639     {
   12640       return !operator==( rhs );
   12641     }
   12642 
   12643   private:
   12644     StructureType sType;
   12645 
   12646   public:
   12647     const void* pNext;
   12648     CommandPoolCreateFlags flags;
   12649     uint32_t queueFamilyIndex;
   12650   };
   12651   static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
   12652 
   12653   enum class CommandPoolResetFlagBits
   12654   {
   12655     eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
   12656   };
   12657 
   12658   using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
   12659 
   12660   inline CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
   12661   {
   12662     return CommandPoolResetFlags( bit0 ) | bit1;
   12663   }
   12664 
   12665   enum class CommandBufferResetFlagBits
   12666   {
   12667     eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
   12668   };
   12669 
   12670   using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
   12671 
   12672   inline CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
   12673   {
   12674     return CommandBufferResetFlags( bit0 ) | bit1;
   12675   }
   12676 
   12677   enum class SampleCountFlagBits
   12678   {
   12679     e1 = VK_SAMPLE_COUNT_1_BIT,
   12680     e2 = VK_SAMPLE_COUNT_2_BIT,
   12681     e4 = VK_SAMPLE_COUNT_4_BIT,
   12682     e8 = VK_SAMPLE_COUNT_8_BIT,
   12683     e16 = VK_SAMPLE_COUNT_16_BIT,
   12684     e32 = VK_SAMPLE_COUNT_32_BIT,
   12685     e64 = VK_SAMPLE_COUNT_64_BIT
   12686   };
   12687 
   12688   using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
   12689 
   12690   inline SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
   12691   {
   12692     return SampleCountFlags( bit0 ) | bit1;
   12693   }
   12694 
   12695   struct ImageFormatProperties
   12696   {
   12697     operator const VkImageFormatProperties&() const
   12698     {
   12699       return *reinterpret_cast<const VkImageFormatProperties*>(this);
   12700     }
   12701 
   12702     bool operator==( ImageFormatProperties const& rhs ) const
   12703     {
   12704       return ( maxExtent == rhs.maxExtent )
   12705           && ( maxMipLevels == rhs.maxMipLevels )
   12706           && ( maxArrayLayers == rhs.maxArrayLayers )
   12707           && ( sampleCounts == rhs.sampleCounts )
   12708           && ( maxResourceSize == rhs.maxResourceSize );
   12709     }
   12710 
   12711     bool operator!=( ImageFormatProperties const& rhs ) const
   12712     {
   12713       return !operator==( rhs );
   12714     }
   12715 
   12716     Extent3D maxExtent;
   12717     uint32_t maxMipLevels;
   12718     uint32_t maxArrayLayers;
   12719     SampleCountFlags sampleCounts;
   12720     DeviceSize maxResourceSize;
   12721   };
   12722   static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
   12723 
   12724   struct ImageCreateInfo
   12725   {
   12726     ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined )
   12727       : sType( StructureType::eImageCreateInfo )
   12728       , pNext( nullptr )
   12729       , flags( flags_ )
   12730       , imageType( imageType_ )
   12731       , format( format_ )
   12732       , extent( extent_ )
   12733       , mipLevels( mipLevels_ )
   12734       , arrayLayers( arrayLayers_ )
   12735       , samples( samples_ )
   12736       , tiling( tiling_ )
   12737       , usage( usage_ )
   12738       , sharingMode( sharingMode_ )
   12739       , queueFamilyIndexCount( queueFamilyIndexCount_ )
   12740       , pQueueFamilyIndices( pQueueFamilyIndices_ )
   12741       , initialLayout( initialLayout_ )
   12742     {
   12743     }
   12744 
   12745     ImageCreateInfo( VkImageCreateInfo const & rhs )
   12746     {
   12747       memcpy( this, &rhs, sizeof(ImageCreateInfo) );
   12748     }
   12749 
   12750     ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
   12751     {
   12752       memcpy( this, &rhs, sizeof(ImageCreateInfo) );
   12753       return *this;
   12754     }
   12755 
   12756     ImageCreateInfo& setSType( StructureType sType_ )
   12757     {
   12758       sType = sType_;
   12759       return *this;
   12760     }
   12761 
   12762     ImageCreateInfo& setPNext( const void* pNext_ )
   12763     {
   12764       pNext = pNext_;
   12765       return *this;
   12766     }
   12767 
   12768     ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
   12769     {
   12770       flags = flags_;
   12771       return *this;
   12772     }
   12773 
   12774     ImageCreateInfo& setImageType( ImageType imageType_ )
   12775     {
   12776       imageType = imageType_;
   12777       return *this;
   12778     }
   12779 
   12780     ImageCreateInfo& setFormat( Format format_ )
   12781     {
   12782       format = format_;
   12783       return *this;
   12784     }
   12785 
   12786     ImageCreateInfo& setExtent( Extent3D extent_ )
   12787     {
   12788       extent = extent_;
   12789       return *this;
   12790     }
   12791 
   12792     ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
   12793     {
   12794       mipLevels = mipLevels_;
   12795       return *this;
   12796     }
   12797 
   12798     ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
   12799     {
   12800       arrayLayers = arrayLayers_;
   12801       return *this;
   12802     }
   12803 
   12804     ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
   12805     {
   12806       samples = samples_;
   12807       return *this;
   12808     }
   12809 
   12810     ImageCreateInfo& setTiling( ImageTiling tiling_ )
   12811     {
   12812       tiling = tiling_;
   12813       return *this;
   12814     }
   12815 
   12816     ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
   12817     {
   12818       usage = usage_;
   12819       return *this;
   12820     }
   12821 
   12822     ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
   12823     {
   12824       sharingMode = sharingMode_;
   12825       return *this;
   12826     }
   12827 
   12828     ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
   12829     {
   12830       queueFamilyIndexCount = queueFamilyIndexCount_;
   12831       return *this;
   12832     }
   12833 
   12834     ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
   12835     {
   12836       pQueueFamilyIndices = pQueueFamilyIndices_;
   12837       return *this;
   12838     }
   12839 
   12840     ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
   12841     {
   12842       initialLayout = initialLayout_;
   12843       return *this;
   12844     }
   12845 
   12846     operator const VkImageCreateInfo&() const
   12847     {
   12848       return *reinterpret_cast<const VkImageCreateInfo*>(this);
   12849     }
   12850 
   12851     bool operator==( ImageCreateInfo const& rhs ) const
   12852     {
   12853       return ( sType == rhs.sType )
   12854           && ( pNext == rhs.pNext )
   12855           && ( flags == rhs.flags )
   12856           && ( imageType == rhs.imageType )
   12857           && ( format == rhs.format )
   12858           && ( extent == rhs.extent )
   12859           && ( mipLevels == rhs.mipLevels )
   12860           && ( arrayLayers == rhs.arrayLayers )
   12861           && ( samples == rhs.samples )
   12862           && ( tiling == rhs.tiling )
   12863           && ( usage == rhs.usage )
   12864           && ( sharingMode == rhs.sharingMode )
   12865           && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
   12866           && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
   12867           && ( initialLayout == rhs.initialLayout );
   12868     }
   12869 
   12870     bool operator!=( ImageCreateInfo const& rhs ) const
   12871     {
   12872       return !operator==( rhs );
   12873     }
   12874 
   12875   private:
   12876     StructureType sType;
   12877 
   12878   public:
   12879     const void* pNext;
   12880     ImageCreateFlags flags;
   12881     ImageType imageType;
   12882     Format format;
   12883     Extent3D extent;
   12884     uint32_t mipLevels;
   12885     uint32_t arrayLayers;
   12886     SampleCountFlagBits samples;
   12887     ImageTiling tiling;
   12888     ImageUsageFlags usage;
   12889     SharingMode sharingMode;
   12890     uint32_t queueFamilyIndexCount;
   12891     const uint32_t* pQueueFamilyIndices;
   12892     ImageLayout initialLayout;
   12893   };
   12894   static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
   12895 
   12896   struct PipelineMultisampleStateCreateInfo
   12897   {
   12898     PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 )
   12899       : sType( StructureType::ePipelineMultisampleStateCreateInfo )
   12900       , pNext( nullptr )
   12901       , flags( flags_ )
   12902       , rasterizationSamples( rasterizationSamples_ )
   12903       , sampleShadingEnable( sampleShadingEnable_ )
   12904       , minSampleShading( minSampleShading_ )
   12905       , pSampleMask( pSampleMask_ )
   12906       , alphaToCoverageEnable( alphaToCoverageEnable_ )
   12907       , alphaToOneEnable( alphaToOneEnable_ )
   12908     {
   12909     }
   12910 
   12911     PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
   12912     {
   12913       memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
   12914     }
   12915 
   12916     PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
   12917     {
   12918       memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
   12919       return *this;
   12920     }
   12921 
   12922     PipelineMultisampleStateCreateInfo& setSType( StructureType sType_ )
   12923     {
   12924       sType = sType_;
   12925       return *this;
   12926     }
   12927 
   12928     PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
   12929     {
   12930       pNext = pNext_;
   12931       return *this;
   12932     }
   12933 
   12934     PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
   12935     {
   12936       flags = flags_;
   12937       return *this;
   12938     }
   12939 
   12940     PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
   12941     {
   12942       rasterizationSamples = rasterizationSamples_;
   12943       return *this;
   12944     }
   12945 
   12946     PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
   12947     {
   12948       sampleShadingEnable = sampleShadingEnable_;
   12949       return *this;
   12950     }
   12951 
   12952     PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
   12953     {
   12954       minSampleShading = minSampleShading_;
   12955       return *this;
   12956     }
   12957 
   12958     PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
   12959     {
   12960       pSampleMask = pSampleMask_;
   12961       return *this;
   12962     }
   12963 
   12964     PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
   12965     {
   12966       alphaToCoverageEnable = alphaToCoverageEnable_;
   12967       return *this;
   12968     }
   12969 
   12970     PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
   12971     {
   12972       alphaToOneEnable = alphaToOneEnable_;
   12973       return *this;
   12974     }
   12975 
   12976     operator const VkPipelineMultisampleStateCreateInfo&() const
   12977     {
   12978       return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
   12979     }
   12980 
   12981     bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
   12982     {
   12983       return ( sType == rhs.sType )
   12984           && ( pNext == rhs.pNext )
   12985           && ( flags == rhs.flags )
   12986           && ( rasterizationSamples == rhs.rasterizationSamples )
   12987           && ( sampleShadingEnable == rhs.sampleShadingEnable )
   12988           && ( minSampleShading == rhs.minSampleShading )
   12989           && ( pSampleMask == rhs.pSampleMask )
   12990           && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
   12991           && ( alphaToOneEnable == rhs.alphaToOneEnable );
   12992     }
   12993 
   12994     bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
   12995     {
   12996       return !operator==( rhs );
   12997     }
   12998 
   12999   private:
   13000     StructureType sType;
   13001 
   13002   public:
   13003     const void* pNext;
   13004     PipelineMultisampleStateCreateFlags flags;
   13005     SampleCountFlagBits rasterizationSamples;
   13006     Bool32 sampleShadingEnable;
   13007     float minSampleShading;
   13008     const SampleMask* pSampleMask;
   13009     Bool32 alphaToCoverageEnable;
   13010     Bool32 alphaToOneEnable;
   13011   };
   13012   static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
   13013 
   13014   struct GraphicsPipelineCreateInfo
   13015   {
   13016     GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
   13017       : sType( StructureType::eGraphicsPipelineCreateInfo )
   13018       , pNext( nullptr )
   13019       , flags( flags_ )
   13020       , stageCount( stageCount_ )
   13021       , pStages( pStages_ )
   13022       , pVertexInputState( pVertexInputState_ )
   13023       , pInputAssemblyState( pInputAssemblyState_ )
   13024       , pTessellationState( pTessellationState_ )
   13025       , pViewportState( pViewportState_ )
   13026       , pRasterizationState( pRasterizationState_ )
   13027       , pMultisampleState( pMultisampleState_ )
   13028       , pDepthStencilState( pDepthStencilState_ )
   13029       , pColorBlendState( pColorBlendState_ )
   13030       , pDynamicState( pDynamicState_ )
   13031       , layout( layout_ )
   13032       , renderPass( renderPass_ )
   13033       , subpass( subpass_ )
   13034       , basePipelineHandle( basePipelineHandle_ )
   13035       , basePipelineIndex( basePipelineIndex_ )
   13036     {
   13037     }
   13038 
   13039     GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
   13040     {
   13041       memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
   13042     }
   13043 
   13044     GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
   13045     {
   13046       memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
   13047       return *this;
   13048     }
   13049 
   13050     GraphicsPipelineCreateInfo& setSType( StructureType sType_ )
   13051     {
   13052       sType = sType_;
   13053       return *this;
   13054     }
   13055 
   13056     GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
   13057     {
   13058       pNext = pNext_;
   13059       return *this;
   13060     }
   13061 
   13062     GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
   13063     {
   13064       flags = flags_;
   13065       return *this;
   13066     }
   13067 
   13068     GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
   13069     {
   13070       stageCount = stageCount_;
   13071       return *this;
   13072     }
   13073 
   13074     GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
   13075     {
   13076       pStages = pStages_;
   13077       return *this;
   13078     }
   13079 
   13080     GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
   13081     {
   13082       pVertexInputState = pVertexInputState_;
   13083       return *this;
   13084     }
   13085 
   13086     GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
   13087     {
   13088       pInputAssemblyState = pInputAssemblyState_;
   13089       return *this;
   13090     }
   13091 
   13092     GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
   13093     {
   13094       pTessellationState = pTessellationState_;
   13095       return *this;
   13096     }
   13097 
   13098     GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
   13099     {
   13100       pViewportState = pViewportState_;
   13101       return *this;
   13102     }
   13103 
   13104     GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
   13105     {
   13106       pRasterizationState = pRasterizationState_;
   13107       return *this;
   13108     }
   13109 
   13110     GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
   13111     {
   13112       pMultisampleState = pMultisampleState_;
   13113       return *this;
   13114     }
   13115 
   13116     GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
   13117     {
   13118       pDepthStencilState = pDepthStencilState_;
   13119       return *this;
   13120     }
   13121 
   13122     GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
   13123     {
   13124       pColorBlendState = pColorBlendState_;
   13125       return *this;
   13126     }
   13127 
   13128     GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
   13129     {
   13130       pDynamicState = pDynamicState_;
   13131       return *this;
   13132     }
   13133 
   13134     GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
   13135     {
   13136       layout = layout_;
   13137       return *this;
   13138     }
   13139 
   13140     GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
   13141     {
   13142       renderPass = renderPass_;
   13143       return *this;
   13144     }
   13145 
   13146     GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
   13147     {
   13148       subpass = subpass_;
   13149       return *this;
   13150     }
   13151 
   13152     GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
   13153     {
   13154       basePipelineHandle = basePipelineHandle_;
   13155       return *this;
   13156     }
   13157 
   13158     GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
   13159     {
   13160       basePipelineIndex = basePipelineIndex_;
   13161       return *this;
   13162     }
   13163 
   13164     operator const VkGraphicsPipelineCreateInfo&() const
   13165     {
   13166       return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
   13167     }
   13168 
   13169     bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
   13170     {
   13171       return ( sType == rhs.sType )
   13172           && ( pNext == rhs.pNext )
   13173           && ( flags == rhs.flags )
   13174           && ( stageCount == rhs.stageCount )
   13175           && ( pStages == rhs.pStages )
   13176           && ( pVertexInputState == rhs.pVertexInputState )
   13177           && ( pInputAssemblyState == rhs.pInputAssemblyState )
   13178           && ( pTessellationState == rhs.pTessellationState )
   13179           && ( pViewportState == rhs.pViewportState )
   13180           && ( pRasterizationState == rhs.pRasterizationState )
   13181           && ( pMultisampleState == rhs.pMultisampleState )
   13182           && ( pDepthStencilState == rhs.pDepthStencilState )
   13183           && ( pColorBlendState == rhs.pColorBlendState )
   13184           && ( pDynamicState == rhs.pDynamicState )
   13185           && ( layout == rhs.layout )
   13186           && ( renderPass == rhs.renderPass )
   13187           && ( subpass == rhs.subpass )
   13188           && ( basePipelineHandle == rhs.basePipelineHandle )
   13189           && ( basePipelineIndex == rhs.basePipelineIndex );
   13190     }
   13191 
   13192     bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
   13193     {
   13194       return !operator==( rhs );
   13195     }
   13196 
   13197   private:
   13198     StructureType sType;
   13199 
   13200   public:
   13201     const void* pNext;
   13202     PipelineCreateFlags flags;
   13203     uint32_t stageCount;
   13204     const PipelineShaderStageCreateInfo* pStages;
   13205     const PipelineVertexInputStateCreateInfo* pVertexInputState;
   13206     const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
   13207     const PipelineTessellationStateCreateInfo* pTessellationState;
   13208     const PipelineViewportStateCreateInfo* pViewportState;
   13209     const PipelineRasterizationStateCreateInfo* pRasterizationState;
   13210     const PipelineMultisampleStateCreateInfo* pMultisampleState;
   13211     const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
   13212     const PipelineColorBlendStateCreateInfo* pColorBlendState;
   13213     const PipelineDynamicStateCreateInfo* pDynamicState;
   13214     PipelineLayout layout;
   13215     RenderPass renderPass;
   13216     uint32_t subpass;
   13217     Pipeline basePipelineHandle;
   13218     int32_t basePipelineIndex;
   13219   };
   13220   static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
   13221 
   13222   struct PhysicalDeviceLimits
   13223   {
   13224     operator const VkPhysicalDeviceLimits&() const
   13225     {
   13226       return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
   13227     }
   13228 
   13229     bool operator==( PhysicalDeviceLimits const& rhs ) const
   13230     {
   13231       return ( maxImageDimension1D == rhs.maxImageDimension1D )
   13232           && ( maxImageDimension2D == rhs.maxImageDimension2D )
   13233           && ( maxImageDimension3D == rhs.maxImageDimension3D )
   13234           && ( maxImageDimensionCube == rhs.maxImageDimensionCube )
   13235           && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
   13236           && ( maxTexelBufferElements == rhs.maxTexelBufferElements )
   13237           && ( maxUniformBufferRange == rhs.maxUniformBufferRange )
   13238           && ( maxStorageBufferRange == rhs.maxStorageBufferRange )
   13239           && ( maxPushConstantsSize == rhs.maxPushConstantsSize )
   13240           && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount )
   13241           && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount )
   13242           && ( bufferImageGranularity == rhs.bufferImageGranularity )
   13243           && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize )
   13244           && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets )
   13245           && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers )
   13246           && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers )
   13247           && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers )
   13248           && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages )
   13249           && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages )
   13250           && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments )
   13251           && ( maxPerStageResources == rhs.maxPerStageResources )
   13252           && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers )
   13253           && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers )
   13254           && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic )
   13255           && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers )
   13256           && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic )
   13257           && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages )
   13258           && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages )
   13259           && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments )
   13260           && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes )
   13261           && ( maxVertexInputBindings == rhs.maxVertexInputBindings )
   13262           && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset )
   13263           && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride )
   13264           && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents )
   13265           && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel )
   13266           && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize )
   13267           && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents )
   13268           && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents )
   13269           && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents )
   13270           && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents )
   13271           && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents )
   13272           && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents )
   13273           && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations )
   13274           && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents )
   13275           && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents )
   13276           && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices )
   13277           && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents )
   13278           && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents )
   13279           && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments )
   13280           && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
   13281           && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
   13282           && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
   13283           && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
   13284           && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
   13285           && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
   13286           && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
   13287           && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
   13288           && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
   13289           && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue )
   13290           && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount )
   13291           && ( maxSamplerLodBias == rhs.maxSamplerLodBias )
   13292           && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy )
   13293           && ( maxViewports == rhs.maxViewports )
   13294           && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
   13295           && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
   13296           && ( viewportSubPixelBits == rhs.viewportSubPixelBits )
   13297           && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
   13298           && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
   13299           && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment )
   13300           && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment )
   13301           && ( minTexelOffset == rhs.minTexelOffset )
   13302           && ( maxTexelOffset == rhs.maxTexelOffset )
   13303           && ( minTexelGatherOffset == rhs.minTexelGatherOffset )
   13304           && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset )
   13305           && ( minInterpolationOffset == rhs.minInterpolationOffset )
   13306           && ( maxInterpolationOffset == rhs.maxInterpolationOffset )
   13307           && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits )
   13308           && ( maxFramebufferWidth == rhs.maxFramebufferWidth )
   13309           && ( maxFramebufferHeight == rhs.maxFramebufferHeight )
   13310           && ( maxFramebufferLayers == rhs.maxFramebufferLayers )
   13311           && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts )
   13312           && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts )
   13313           && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts )
   13314           && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts )
   13315           && ( maxColorAttachments == rhs.maxColorAttachments )
   13316           && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts )
   13317           && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts )
   13318           && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts )
   13319           && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts )
   13320           && ( storageImageSampleCounts == rhs.storageImageSampleCounts )
   13321           && ( maxSampleMaskWords == rhs.maxSampleMaskWords )
   13322           && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics )
   13323           && ( timestampPeriod == rhs.timestampPeriod )
   13324           && ( maxClipDistances == rhs.maxClipDistances )
   13325           && ( maxCullDistances == rhs.maxCullDistances )
   13326           && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances )
   13327           && ( discreteQueuePriorities == rhs.discreteQueuePriorities )
   13328           && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
   13329           && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
   13330           && ( pointSizeGranularity == rhs.pointSizeGranularity )
   13331           && ( lineWidthGranularity == rhs.lineWidthGranularity )
   13332           && ( strictLines == rhs.strictLines )
   13333           && ( standardSampleLocations == rhs.standardSampleLocations )
   13334           && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment )
   13335           && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment )
   13336           && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
   13337     }
   13338 
   13339     bool operator!=( PhysicalDeviceLimits const& rhs ) const
   13340     {
   13341       return !operator==( rhs );
   13342     }
   13343 
   13344     uint32_t maxImageDimension1D;
   13345     uint32_t maxImageDimension2D;
   13346     uint32_t maxImageDimension3D;
   13347     uint32_t maxImageDimensionCube;
   13348     uint32_t maxImageArrayLayers;
   13349     uint32_t maxTexelBufferElements;
   13350     uint32_t maxUniformBufferRange;
   13351     uint32_t maxStorageBufferRange;
   13352     uint32_t maxPushConstantsSize;
   13353     uint32_t maxMemoryAllocationCount;
   13354     uint32_t maxSamplerAllocationCount;
   13355     DeviceSize bufferImageGranularity;
   13356     DeviceSize sparseAddressSpaceSize;
   13357     uint32_t maxBoundDescriptorSets;
   13358     uint32_t maxPerStageDescriptorSamplers;
   13359     uint32_t maxPerStageDescriptorUniformBuffers;
   13360     uint32_t maxPerStageDescriptorStorageBuffers;
   13361     uint32_t maxPerStageDescriptorSampledImages;
   13362     uint32_t maxPerStageDescriptorStorageImages;
   13363     uint32_t maxPerStageDescriptorInputAttachments;
   13364     uint32_t maxPerStageResources;
   13365     uint32_t maxDescriptorSetSamplers;
   13366     uint32_t maxDescriptorSetUniformBuffers;
   13367     uint32_t maxDescriptorSetUniformBuffersDynamic;
   13368     uint32_t maxDescriptorSetStorageBuffers;
   13369     uint32_t maxDescriptorSetStorageBuffersDynamic;
   13370     uint32_t maxDescriptorSetSampledImages;
   13371     uint32_t maxDescriptorSetStorageImages;
   13372     uint32_t maxDescriptorSetInputAttachments;
   13373     uint32_t maxVertexInputAttributes;
   13374     uint32_t maxVertexInputBindings;
   13375     uint32_t maxVertexInputAttributeOffset;
   13376     uint32_t maxVertexInputBindingStride;
   13377     uint32_t maxVertexOutputComponents;
   13378     uint32_t maxTessellationGenerationLevel;
   13379     uint32_t maxTessellationPatchSize;
   13380     uint32_t maxTessellationControlPerVertexInputComponents;
   13381     uint32_t maxTessellationControlPerVertexOutputComponents;
   13382     uint32_t maxTessellationControlPerPatchOutputComponents;
   13383     uint32_t maxTessellationControlTotalOutputComponents;
   13384     uint32_t maxTessellationEvaluationInputComponents;
   13385     uint32_t maxTessellationEvaluationOutputComponents;
   13386     uint32_t maxGeometryShaderInvocations;
   13387     uint32_t maxGeometryInputComponents;
   13388     uint32_t maxGeometryOutputComponents;
   13389     uint32_t maxGeometryOutputVertices;
   13390     uint32_t maxGeometryTotalOutputComponents;
   13391     uint32_t maxFragmentInputComponents;
   13392     uint32_t maxFragmentOutputAttachments;
   13393     uint32_t maxFragmentDualSrcAttachments;
   13394     uint32_t maxFragmentCombinedOutputResources;
   13395     uint32_t maxComputeSharedMemorySize;
   13396     uint32_t maxComputeWorkGroupCount[3];
   13397     uint32_t maxComputeWorkGroupInvocations;
   13398     uint32_t maxComputeWorkGroupSize[3];
   13399     uint32_t subPixelPrecisionBits;
   13400     uint32_t subTexelPrecisionBits;
   13401     uint32_t mipmapPrecisionBits;
   13402     uint32_t maxDrawIndexedIndexValue;
   13403     uint32_t maxDrawIndirectCount;
   13404     float maxSamplerLodBias;
   13405     float maxSamplerAnisotropy;
   13406     uint32_t maxViewports;
   13407     uint32_t maxViewportDimensions[2];
   13408     float viewportBoundsRange[2];
   13409     uint32_t viewportSubPixelBits;
   13410     size_t minMemoryMapAlignment;
   13411     DeviceSize minTexelBufferOffsetAlignment;
   13412     DeviceSize minUniformBufferOffsetAlignment;
   13413     DeviceSize minStorageBufferOffsetAlignment;
   13414     int32_t minTexelOffset;
   13415     uint32_t maxTexelOffset;
   13416     int32_t minTexelGatherOffset;
   13417     uint32_t maxTexelGatherOffset;
   13418     float minInterpolationOffset;
   13419     float maxInterpolationOffset;
   13420     uint32_t subPixelInterpolationOffsetBits;
   13421     uint32_t maxFramebufferWidth;
   13422     uint32_t maxFramebufferHeight;
   13423     uint32_t maxFramebufferLayers;
   13424     SampleCountFlags framebufferColorSampleCounts;
   13425     SampleCountFlags framebufferDepthSampleCounts;
   13426     SampleCountFlags framebufferStencilSampleCounts;
   13427     SampleCountFlags framebufferNoAttachmentsSampleCounts;
   13428     uint32_t maxColorAttachments;
   13429     SampleCountFlags sampledImageColorSampleCounts;
   13430     SampleCountFlags sampledImageIntegerSampleCounts;
   13431     SampleCountFlags sampledImageDepthSampleCounts;
   13432     SampleCountFlags sampledImageStencilSampleCounts;
   13433     SampleCountFlags storageImageSampleCounts;
   13434     uint32_t maxSampleMaskWords;
   13435     Bool32 timestampComputeAndGraphics;
   13436     float timestampPeriod;
   13437     uint32_t maxClipDistances;
   13438     uint32_t maxCullDistances;
   13439     uint32_t maxCombinedClipAndCullDistances;
   13440     uint32_t discreteQueuePriorities;
   13441     float pointSizeRange[2];
   13442     float lineWidthRange[2];
   13443     float pointSizeGranularity;
   13444     float lineWidthGranularity;
   13445     Bool32 strictLines;
   13446     Bool32 standardSampleLocations;
   13447     DeviceSize optimalBufferCopyOffsetAlignment;
   13448     DeviceSize optimalBufferCopyRowPitchAlignment;
   13449     DeviceSize nonCoherentAtomSize;
   13450   };
   13451   static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
   13452 
   13453   struct PhysicalDeviceProperties
   13454   {
   13455     operator const VkPhysicalDeviceProperties&() const
   13456     {
   13457       return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
   13458     }
   13459 
   13460     bool operator==( PhysicalDeviceProperties const& rhs ) const
   13461     {
   13462       return ( apiVersion == rhs.apiVersion )
   13463           && ( driverVersion == rhs.driverVersion )
   13464           && ( vendorID == rhs.vendorID )
   13465           && ( deviceID == rhs.deviceID )
   13466           && ( deviceType == rhs.deviceType )
   13467           && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
   13468           && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
   13469           && ( limits == rhs.limits )
   13470           && ( sparseProperties == rhs.sparseProperties );
   13471     }
   13472 
   13473     bool operator!=( PhysicalDeviceProperties const& rhs ) const
   13474     {
   13475       return !operator==( rhs );
   13476     }
   13477 
   13478     uint32_t apiVersion;
   13479     uint32_t driverVersion;
   13480     uint32_t vendorID;
   13481     uint32_t deviceID;
   13482     PhysicalDeviceType deviceType;
   13483     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
   13484     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
   13485     PhysicalDeviceLimits limits;
   13486     PhysicalDeviceSparseProperties sparseProperties;
   13487   };
   13488   static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
   13489 
   13490   enum class AttachmentDescriptionFlagBits
   13491   {
   13492     eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
   13493   };
   13494 
   13495   using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
   13496 
   13497   inline AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
   13498   {
   13499     return AttachmentDescriptionFlags( bit0 ) | bit1;
   13500   }
   13501 
   13502   struct AttachmentDescription
   13503   {
   13504     AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), Format format_ = Format::eUndefined, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, ImageLayout initialLayout_ = ImageLayout::eUndefined, ImageLayout finalLayout_ = ImageLayout::eUndefined )
   13505       : flags( flags_ )
   13506       , format( format_ )
   13507       , samples( samples_ )
   13508       , loadOp( loadOp_ )
   13509       , storeOp( storeOp_ )
   13510       , stencilLoadOp( stencilLoadOp_ )
   13511       , stencilStoreOp( stencilStoreOp_ )
   13512       , initialLayout( initialLayout_ )
   13513       , finalLayout( finalLayout_ )
   13514     {
   13515     }
   13516 
   13517     AttachmentDescription( VkAttachmentDescription const & rhs )
   13518     {
   13519       memcpy( this, &rhs, sizeof(AttachmentDescription) );
   13520     }
   13521 
   13522     AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
   13523     {
   13524       memcpy( this, &rhs, sizeof(AttachmentDescription) );
   13525       return *this;
   13526     }
   13527 
   13528     AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
   13529     {
   13530       flags = flags_;
   13531       return *this;
   13532     }
   13533 
   13534     AttachmentDescription& setFormat( Format format_ )
   13535     {
   13536       format = format_;
   13537       return *this;
   13538     }
   13539 
   13540     AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
   13541     {
   13542       samples = samples_;
   13543       return *this;
   13544     }
   13545 
   13546     AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
   13547     {
   13548       loadOp = loadOp_;
   13549       return *this;
   13550     }
   13551 
   13552     AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
   13553     {
   13554       storeOp = storeOp_;
   13555       return *this;
   13556     }
   13557 
   13558     AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
   13559     {
   13560       stencilLoadOp = stencilLoadOp_;
   13561       return *this;
   13562     }
   13563 
   13564     AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
   13565     {
   13566       stencilStoreOp = stencilStoreOp_;
   13567       return *this;
   13568     }
   13569 
   13570     AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
   13571     {
   13572       initialLayout = initialLayout_;
   13573       return *this;
   13574     }
   13575 
   13576     AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
   13577     {
   13578       finalLayout = finalLayout_;
   13579       return *this;
   13580     }
   13581 
   13582     operator const VkAttachmentDescription&() const
   13583     {
   13584       return *reinterpret_cast<const VkAttachmentDescription*>(this);
   13585     }
   13586 
   13587     bool operator==( AttachmentDescription const& rhs ) const
   13588     {
   13589       return ( flags == rhs.flags )
   13590           && ( format == rhs.format )
   13591           && ( samples == rhs.samples )
   13592           && ( loadOp == rhs.loadOp )
   13593           && ( storeOp == rhs.storeOp )
   13594           && ( stencilLoadOp == rhs.stencilLoadOp )
   13595           && ( stencilStoreOp == rhs.stencilStoreOp )
   13596           && ( initialLayout == rhs.initialLayout )
   13597           && ( finalLayout == rhs.finalLayout );
   13598     }
   13599 
   13600     bool operator!=( AttachmentDescription const& rhs ) const
   13601     {
   13602       return !operator==( rhs );
   13603     }
   13604 
   13605     AttachmentDescriptionFlags flags;
   13606     Format format;
   13607     SampleCountFlagBits samples;
   13608     AttachmentLoadOp loadOp;
   13609     AttachmentStoreOp storeOp;
   13610     AttachmentLoadOp stencilLoadOp;
   13611     AttachmentStoreOp stencilStoreOp;
   13612     ImageLayout initialLayout;
   13613     ImageLayout finalLayout;
   13614   };
   13615   static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
   13616 
   13617   enum class StencilFaceFlagBits
   13618   {
   13619     eFront = VK_STENCIL_FACE_FRONT_BIT,
   13620     eBack = VK_STENCIL_FACE_BACK_BIT,
   13621     eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
   13622   };
   13623 
   13624   using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
   13625 
   13626   inline StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
   13627   {
   13628     return StencilFaceFlags( bit0 ) | bit1;
   13629   }
   13630 
   13631   enum class DescriptorPoolCreateFlagBits
   13632   {
   13633     eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
   13634   };
   13635 
   13636   using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
   13637 
   13638   inline DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
   13639   {
   13640     return DescriptorPoolCreateFlags( bit0 ) | bit1;
   13641   }
   13642 
   13643   struct DescriptorPoolCreateInfo
   13644   {
   13645     DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr )
   13646       : sType( StructureType::eDescriptorPoolCreateInfo )
   13647       , pNext( nullptr )
   13648       , flags( flags_ )
   13649       , maxSets( maxSets_ )
   13650       , poolSizeCount( poolSizeCount_ )
   13651       , pPoolSizes( pPoolSizes_ )
   13652     {
   13653     }
   13654 
   13655     DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
   13656     {
   13657       memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
   13658     }
   13659 
   13660     DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
   13661     {
   13662       memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
   13663       return *this;
   13664     }
   13665 
   13666     DescriptorPoolCreateInfo& setSType( StructureType sType_ )
   13667     {
   13668       sType = sType_;
   13669       return *this;
   13670     }
   13671 
   13672     DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
   13673     {
   13674       pNext = pNext_;
   13675       return *this;
   13676     }
   13677 
   13678     DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
   13679     {
   13680       flags = flags_;
   13681       return *this;
   13682     }
   13683 
   13684     DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
   13685     {
   13686       maxSets = maxSets_;
   13687       return *this;
   13688     }
   13689 
   13690     DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
   13691     {
   13692       poolSizeCount = poolSizeCount_;
   13693       return *this;
   13694     }
   13695 
   13696     DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
   13697     {
   13698       pPoolSizes = pPoolSizes_;
   13699       return *this;
   13700     }
   13701 
   13702     operator const VkDescriptorPoolCreateInfo&() const
   13703     {
   13704       return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
   13705     }
   13706 
   13707     bool operator==( DescriptorPoolCreateInfo const& rhs ) const
   13708     {
   13709       return ( sType == rhs.sType )
   13710           && ( pNext == rhs.pNext )
   13711           && ( flags == rhs.flags )
   13712           && ( maxSets == rhs.maxSets )
   13713           && ( poolSizeCount == rhs.poolSizeCount )
   13714           && ( pPoolSizes == rhs.pPoolSizes );
   13715     }
   13716 
   13717     bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
   13718     {
   13719       return !operator==( rhs );
   13720     }
   13721 
   13722   private:
   13723     StructureType sType;
   13724 
   13725   public:
   13726     const void* pNext;
   13727     DescriptorPoolCreateFlags flags;
   13728     uint32_t maxSets;
   13729     uint32_t poolSizeCount;
   13730     const DescriptorPoolSize* pPoolSizes;
   13731   };
   13732   static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
   13733 
   13734   enum class DependencyFlagBits
   13735   {
   13736     eByRegion = VK_DEPENDENCY_BY_REGION_BIT
   13737   };
   13738 
   13739   using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
   13740 
   13741   inline DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
   13742   {
   13743     return DependencyFlags( bit0 ) | bit1;
   13744   }
   13745 
   13746   class CommandBuffer
   13747   {
   13748   public:
   13749     CommandBuffer()
   13750       : m_commandBuffer(VK_NULL_HANDLE)
   13751     {}
   13752 
   13753 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   13754     CommandBuffer(VkCommandBuffer commandBuffer)
   13755        : m_commandBuffer(commandBuffer)
   13756     {}
   13757 
   13758     CommandBuffer& operator=(VkCommandBuffer commandBuffer)
   13759     {
   13760       m_commandBuffer = commandBuffer;
   13761       return *this;
   13762     }
   13763 #endif
   13764 
   13765     bool operator==(CommandBuffer const &rhs) const
   13766     {
   13767       return m_commandBuffer == rhs.m_commandBuffer;
   13768     }
   13769 
   13770     bool operator!=(CommandBuffer const &rhs) const
   13771     {
   13772       return m_commandBuffer != rhs.m_commandBuffer;
   13773     }
   13774 
   13775     bool operator<(CommandBuffer const &rhs) const
   13776     {
   13777       return m_commandBuffer < rhs.m_commandBuffer;
   13778     }
   13779 
   13780     Result begin( const CommandBufferBeginInfo* pBeginInfo ) const
   13781     {
   13782       return static_cast<Result>( vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( pBeginInfo ) ) );
   13783     }
   13784 
   13785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13786     ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo ) const
   13787     {
   13788       Result result = static_cast<Result>( vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( &beginInfo ) ) );
   13789       return createResultValue( result, "vk::CommandBuffer::begin" );
   13790     }
   13791 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13792 
   13793 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13794     Result end(  ) const
   13795     {
   13796       return static_cast<Result>( vkEndCommandBuffer( m_commandBuffer ) );
   13797     }
   13798 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13799 
   13800 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13801     ResultValueType<void>::type end() const
   13802     {
   13803       Result result = static_cast<Result>( vkEndCommandBuffer( m_commandBuffer ) );
   13804       return createResultValue( result, "vk::CommandBuffer::end" );
   13805     }
   13806 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13807 
   13808 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13809     Result reset( CommandBufferResetFlags flags ) const
   13810     {
   13811       return static_cast<Result>( vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
   13812     }
   13813 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13814 
   13815 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13816     ResultValueType<void>::type reset( CommandBufferResetFlags flags ) const
   13817     {
   13818       Result result = static_cast<Result>( vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
   13819       return createResultValue( result, "vk::CommandBuffer::reset" );
   13820     }
   13821 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13822 
   13823 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13824     void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) const
   13825     {
   13826       vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
   13827     }
   13828 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13829 
   13830 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13831     void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) const
   13832     {
   13833       vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
   13834     }
   13835 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13836 
   13837     void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports ) const
   13838     {
   13839       vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
   13840     }
   13841 
   13842 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13843     void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports ) const
   13844     {
   13845       vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
   13846     }
   13847 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13848 
   13849     void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors ) const
   13850     {
   13851       vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
   13852     }
   13853 
   13854 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13855     void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors ) const
   13856     {
   13857       vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
   13858     }
   13859 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13860 
   13861 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13862     void setLineWidth( float lineWidth ) const
   13863     {
   13864       vkCmdSetLineWidth( m_commandBuffer, lineWidth );
   13865     }
   13866 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13867 
   13868 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13869     void setLineWidth( float lineWidth ) const
   13870     {
   13871       vkCmdSetLineWidth( m_commandBuffer, lineWidth );
   13872     }
   13873 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13874 
   13875 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13876     void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
   13877     {
   13878       vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
   13879     }
   13880 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13881 
   13882 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13883     void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
   13884     {
   13885       vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
   13886     }
   13887 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13888 
   13889 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13890     void setBlendConstants( const float blendConstants[4] ) const
   13891     {
   13892       vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
   13893     }
   13894 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13895 
   13896 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13897     void setBlendConstants( const float blendConstants[4] ) const
   13898     {
   13899       vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
   13900     }
   13901 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13902 
   13903 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13904     void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const
   13905     {
   13906       vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
   13907     }
   13908 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13909 
   13910 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13911     void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const
   13912     {
   13913       vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
   13914     }
   13915 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13916 
   13917 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13918     void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const
   13919     {
   13920       vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
   13921     }
   13922 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13923 
   13924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13925     void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const
   13926     {
   13927       vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
   13928     }
   13929 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13930 
   13931 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13932     void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const
   13933     {
   13934       vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
   13935     }
   13936 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13937 
   13938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13939     void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const
   13940     {
   13941       vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
   13942     }
   13943 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13944 
   13945 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13946     void setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const
   13947     {
   13948       vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
   13949     }
   13950 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13951 
   13952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13953     void setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const
   13954     {
   13955       vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
   13956     }
   13957 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13958 
   13959     void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const
   13960     {
   13961       vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets );
   13962     }
   13963 
   13964 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13965     void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets ) const
   13966     {
   13967       vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() );
   13968     }
   13969 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13970 
   13971 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13972     void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType ) const
   13973     {
   13974       vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
   13975     }
   13976 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13977 
   13978 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13979     void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType ) const
   13980     {
   13981       vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
   13982     }
   13983 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   13984 
   13985     void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets ) const
   13986     {
   13987       vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets );
   13988     }
   13989 
   13990 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   13991     void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets ) const
   13992     {
   13993 #ifdef VULKAN_HPP_NO_EXCEPTIONS
   13994       assert( buffers.size() == offsets.size() );
   13995 #else
   13996       if ( buffers.size() != offsets.size() )
   13997       {
   13998         throw std::logic_error( "vk::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
   13999       }
   14000 #endif  // VULKAN_HPP_NO_EXCEPTIONS
   14001       vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data() );
   14002     }
   14003 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14004 
   14005 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14006     void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
   14007     {
   14008       vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
   14009     }
   14010 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14011 
   14012 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14013     void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
   14014     {
   14015       vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
   14016     }
   14017 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14018 
   14019 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14020     void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const
   14021     {
   14022       vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
   14023     }
   14024 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14025 
   14026 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14027     void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const
   14028     {
   14029       vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
   14030     }
   14031 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14032 
   14033 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14034     void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const
   14035     {
   14036       vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
   14037     }
   14038 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14039 
   14040 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14041     void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const
   14042     {
   14043       vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
   14044     }
   14045 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14046 
   14047 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14048     void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const
   14049     {
   14050       vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
   14051     }
   14052 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14053 
   14054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14055     void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const
   14056     {
   14057       vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
   14058     }
   14059 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14060 
   14061 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14062     void dispatch( uint32_t x, uint32_t y, uint32_t z ) const
   14063     {
   14064       vkCmdDispatch( m_commandBuffer, x, y, z );
   14065     }
   14066 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14067 
   14068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14069     void dispatch( uint32_t x, uint32_t y, uint32_t z ) const
   14070     {
   14071       vkCmdDispatch( m_commandBuffer, x, y, z );
   14072     }
   14073 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14074 
   14075 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14076     void dispatchIndirect( Buffer buffer, DeviceSize offset ) const
   14077     {
   14078       vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
   14079     }
   14080 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14081 
   14082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14083     void dispatchIndirect( Buffer buffer, DeviceSize offset ) const
   14084     {
   14085       vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
   14086     }
   14087 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14088 
   14089     void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions ) const
   14090     {
   14091       vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
   14092     }
   14093 
   14094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14095     void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions ) const
   14096     {
   14097       vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
   14098     }
   14099 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14100 
   14101     void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions ) const
   14102     {
   14103       vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageCopy*>( pRegions ) );
   14104     }
   14105 
   14106 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14107     void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions ) const
   14108     {
   14109       vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageCopy*>( regions.data() ) );
   14110     }
   14111 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14112 
   14113     void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter ) const
   14114     {
   14115       vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageBlit*>( pRegions ), static_cast<VkFilter>( filter ) );
   14116     }
   14117 
   14118 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14119     void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter ) const
   14120     {
   14121       vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageBlit*>( regions.data() ), static_cast<VkFilter>( filter ) );
   14122     }
   14123 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14124 
   14125     void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions ) const
   14126     {
   14127       vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
   14128     }
   14129 
   14130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14131     void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions ) const
   14132     {
   14133       vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
   14134     }
   14135 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14136 
   14137     void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions ) const
   14138     {
   14139       vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
   14140     }
   14141 
   14142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14143     void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions ) const
   14144     {
   14145       vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
   14146     }
   14147 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14148 
   14149     void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData ) const
   14150     {
   14151       vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, dataSize, pData );
   14152     }
   14153 
   14154 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14155     template <typename T>
   14156     void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data ) const
   14157     {
   14158       vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
   14159     }
   14160 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14161 
   14162 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14163     void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const
   14164     {
   14165       vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
   14166     }
   14167 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14168 
   14169 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14170     void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const
   14171     {
   14172       vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
   14173     }
   14174 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14175 
   14176     void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const
   14177     {
   14178       vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( pColor ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
   14179     }
   14180 
   14181 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14182     void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges ) const
   14183     {
   14184       vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( &color ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
   14185     }
   14186 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14187 
   14188     void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const
   14189     {
   14190       vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( pDepthStencil ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
   14191     }
   14192 
   14193 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14194     void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges ) const
   14195     {
   14196       vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( &depthStencil ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
   14197     }
   14198 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14199 
   14200     void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects ) const
   14201     {
   14202       vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
   14203     }
   14204 
   14205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14206     void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects ) const
   14207     {
   14208       vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
   14209     }
   14210 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14211 
   14212     void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions ) const
   14213     {
   14214       vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageResolve*>( pRegions ) );
   14215     }
   14216 
   14217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14218     void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions ) const
   14219     {
   14220       vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageResolve*>( regions.data() ) );
   14221     }
   14222 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14223 
   14224 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14225     void setEvent( Event event, PipelineStageFlags stageMask ) const
   14226     {
   14227       vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   14228     }
   14229 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14230 
   14231 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14232     void setEvent( Event event, PipelineStageFlags stageMask ) const
   14233     {
   14234       vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   14235     }
   14236 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14237 
   14238 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14239     void resetEvent( Event event, PipelineStageFlags stageMask ) const
   14240     {
   14241       vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   14242     }
   14243 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14244 
   14245 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14246     void resetEvent( Event event, PipelineStageFlags stageMask ) const
   14247     {
   14248       vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
   14249     }
   14250 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14251 
   14252     void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) const
   14253     {
   14254       vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast<const VkEvent*>( pEvents ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
   14255     }
   14256 
   14257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14258     void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const
   14259     {
   14260       vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast<const VkEvent*>( events.data() ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
   14261     }
   14262 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14263 
   14264     void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) const
   14265     {
   14266       vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
   14267     }
   14268 
   14269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14270     void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const
   14271     {
   14272       vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
   14273     }
   14274 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14275 
   14276 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14277     void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const
   14278     {
   14279       vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
   14280     }
   14281 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14282 
   14283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14284     void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const
   14285     {
   14286       vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
   14287     }
   14288 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14289 
   14290 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14291     void endQuery( QueryPool queryPool, uint32_t query ) const
   14292     {
   14293       vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
   14294     }
   14295 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14296 
   14297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14298     void endQuery( QueryPool queryPool, uint32_t query ) const
   14299     {
   14300       vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
   14301     }
   14302 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14303 
   14304 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14305     void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const
   14306     {
   14307       vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
   14308     }
   14309 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14310 
   14311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14312     void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const
   14313     {
   14314       vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
   14315     }
   14316 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14317 
   14318 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14319     void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) const
   14320     {
   14321       vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
   14322     }
   14323 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14324 
   14325 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14326     void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) const
   14327     {
   14328       vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
   14329     }
   14330 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14331 
   14332 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14333     void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) const
   14334     {
   14335       vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
   14336     }
   14337 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14338 
   14339 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14340     void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) const
   14341     {
   14342       vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
   14343     }
   14344 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14345 
   14346     void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const
   14347     {
   14348       vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
   14349     }
   14350 
   14351 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14352     template <typename T>
   14353     void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values ) const
   14354     {
   14355       vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
   14356     }
   14357 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14358 
   14359     void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents ) const
   14360     {
   14361       vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   14362     }
   14363 
   14364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14365     void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const
   14366     {
   14367       vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
   14368     }
   14369 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14370 
   14371 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14372     void nextSubpass( SubpassContents contents ) const
   14373     {
   14374       vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
   14375     }
   14376 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14377 
   14378 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14379     void nextSubpass( SubpassContents contents ) const
   14380     {
   14381       vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
   14382     }
   14383 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14384 
   14385 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14386     void endRenderPass(  ) const
   14387     {
   14388       vkCmdEndRenderPass( m_commandBuffer );
   14389     }
   14390 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14391 
   14392 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14393     void endRenderPass() const
   14394     {
   14395       vkCmdEndRenderPass( m_commandBuffer );
   14396     }
   14397 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14398 
   14399     void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const
   14400     {
   14401       vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
   14402     }
   14403 
   14404 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14405     void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers ) const
   14406     {
   14407       vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
   14408     }
   14409 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14410 
   14411     void debugMarkerBeginEXT( DebugMarkerMarkerInfoEXT* pMarkerInfo ) const
   14412     {
   14413       vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
   14414     }
   14415 
   14416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14417     DebugMarkerMarkerInfoEXT debugMarkerBeginEXT() const
   14418     {
   14419       DebugMarkerMarkerInfoEXT markerInfo;
   14420       vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) );
   14421       return markerInfo;
   14422     }
   14423 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14424 
   14425 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14426     void debugMarkerEndEXT(  ) const
   14427     {
   14428       vkCmdDebugMarkerEndEXT( m_commandBuffer );
   14429     }
   14430 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14431 
   14432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14433     void debugMarkerEndEXT() const
   14434     {
   14435       vkCmdDebugMarkerEndEXT( m_commandBuffer );
   14436     }
   14437 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14438 
   14439     void debugMarkerInsertEXT( DebugMarkerMarkerInfoEXT* pMarkerInfo ) const
   14440     {
   14441       vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
   14442     }
   14443 
   14444 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14445     DebugMarkerMarkerInfoEXT debugMarkerInsertEXT() const
   14446     {
   14447       DebugMarkerMarkerInfoEXT markerInfo;
   14448       vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) );
   14449       return markerInfo;
   14450     }
   14451 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14452 
   14453 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14454     void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
   14455     {
   14456       vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
   14457     }
   14458 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14459 
   14460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14461     void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
   14462     {
   14463       vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
   14464     }
   14465 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14466 
   14467 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14468     void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
   14469     {
   14470       vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
   14471     }
   14472 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14473 
   14474 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14475     void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
   14476     {
   14477       vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
   14478     }
   14479 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14480 
   14481 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   14482     explicit
   14483 #endif
   14484     operator VkCommandBuffer() const
   14485     {
   14486       return m_commandBuffer;
   14487     }
   14488 
   14489     explicit operator bool() const
   14490     {
   14491       return m_commandBuffer != VK_NULL_HANDLE;
   14492     }
   14493 
   14494     bool operator!() const
   14495     {
   14496       return m_commandBuffer == VK_NULL_HANDLE;
   14497     }
   14498 
   14499   private:
   14500     VkCommandBuffer m_commandBuffer;
   14501   };
   14502   static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
   14503 
   14504   struct SubpassDependency
   14505   {
   14506     SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() )
   14507       : srcSubpass( srcSubpass_ )
   14508       , dstSubpass( dstSubpass_ )
   14509       , srcStageMask( srcStageMask_ )
   14510       , dstStageMask( dstStageMask_ )
   14511       , srcAccessMask( srcAccessMask_ )
   14512       , dstAccessMask( dstAccessMask_ )
   14513       , dependencyFlags( dependencyFlags_ )
   14514     {
   14515     }
   14516 
   14517     SubpassDependency( VkSubpassDependency const & rhs )
   14518     {
   14519       memcpy( this, &rhs, sizeof(SubpassDependency) );
   14520     }
   14521 
   14522     SubpassDependency& operator=( VkSubpassDependency const & rhs )
   14523     {
   14524       memcpy( this, &rhs, sizeof(SubpassDependency) );
   14525       return *this;
   14526     }
   14527 
   14528     SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
   14529     {
   14530       srcSubpass = srcSubpass_;
   14531       return *this;
   14532     }
   14533 
   14534     SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
   14535     {
   14536       dstSubpass = dstSubpass_;
   14537       return *this;
   14538     }
   14539 
   14540     SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
   14541     {
   14542       srcStageMask = srcStageMask_;
   14543       return *this;
   14544     }
   14545 
   14546     SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
   14547     {
   14548       dstStageMask = dstStageMask_;
   14549       return *this;
   14550     }
   14551 
   14552     SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
   14553     {
   14554       srcAccessMask = srcAccessMask_;
   14555       return *this;
   14556     }
   14557 
   14558     SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
   14559     {
   14560       dstAccessMask = dstAccessMask_;
   14561       return *this;
   14562     }
   14563 
   14564     SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
   14565     {
   14566       dependencyFlags = dependencyFlags_;
   14567       return *this;
   14568     }
   14569 
   14570     operator const VkSubpassDependency&() const
   14571     {
   14572       return *reinterpret_cast<const VkSubpassDependency*>(this);
   14573     }
   14574 
   14575     bool operator==( SubpassDependency const& rhs ) const
   14576     {
   14577       return ( srcSubpass == rhs.srcSubpass )
   14578           && ( dstSubpass == rhs.dstSubpass )
   14579           && ( srcStageMask == rhs.srcStageMask )
   14580           && ( dstStageMask == rhs.dstStageMask )
   14581           && ( srcAccessMask == rhs.srcAccessMask )
   14582           && ( dstAccessMask == rhs.dstAccessMask )
   14583           && ( dependencyFlags == rhs.dependencyFlags );
   14584     }
   14585 
   14586     bool operator!=( SubpassDependency const& rhs ) const
   14587     {
   14588       return !operator==( rhs );
   14589     }
   14590 
   14591     uint32_t srcSubpass;
   14592     uint32_t dstSubpass;
   14593     PipelineStageFlags srcStageMask;
   14594     PipelineStageFlags dstStageMask;
   14595     AccessFlags srcAccessMask;
   14596     AccessFlags dstAccessMask;
   14597     DependencyFlags dependencyFlags;
   14598   };
   14599   static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
   14600 
   14601   struct RenderPassCreateInfo
   14602   {
   14603     RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, const AttachmentDescription* pAttachments_ = nullptr, uint32_t subpassCount_ = 0, const SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const SubpassDependency* pDependencies_ = nullptr )
   14604       : sType( StructureType::eRenderPassCreateInfo )
   14605       , pNext( nullptr )
   14606       , flags( flags_ )
   14607       , attachmentCount( attachmentCount_ )
   14608       , pAttachments( pAttachments_ )
   14609       , subpassCount( subpassCount_ )
   14610       , pSubpasses( pSubpasses_ )
   14611       , dependencyCount( dependencyCount_ )
   14612       , pDependencies( pDependencies_ )
   14613     {
   14614     }
   14615 
   14616     RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
   14617     {
   14618       memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
   14619     }
   14620 
   14621     RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
   14622     {
   14623       memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
   14624       return *this;
   14625     }
   14626 
   14627     RenderPassCreateInfo& setSType( StructureType sType_ )
   14628     {
   14629       sType = sType_;
   14630       return *this;
   14631     }
   14632 
   14633     RenderPassCreateInfo& setPNext( const void* pNext_ )
   14634     {
   14635       pNext = pNext_;
   14636       return *this;
   14637     }
   14638 
   14639     RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
   14640     {
   14641       flags = flags_;
   14642       return *this;
   14643     }
   14644 
   14645     RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
   14646     {
   14647       attachmentCount = attachmentCount_;
   14648       return *this;
   14649     }
   14650 
   14651     RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
   14652     {
   14653       pAttachments = pAttachments_;
   14654       return *this;
   14655     }
   14656 
   14657     RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
   14658     {
   14659       subpassCount = subpassCount_;
   14660       return *this;
   14661     }
   14662 
   14663     RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
   14664     {
   14665       pSubpasses = pSubpasses_;
   14666       return *this;
   14667     }
   14668 
   14669     RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
   14670     {
   14671       dependencyCount = dependencyCount_;
   14672       return *this;
   14673     }
   14674 
   14675     RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
   14676     {
   14677       pDependencies = pDependencies_;
   14678       return *this;
   14679     }
   14680 
   14681     operator const VkRenderPassCreateInfo&() const
   14682     {
   14683       return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
   14684     }
   14685 
   14686     bool operator==( RenderPassCreateInfo const& rhs ) const
   14687     {
   14688       return ( sType == rhs.sType )
   14689           && ( pNext == rhs.pNext )
   14690           && ( flags == rhs.flags )
   14691           && ( attachmentCount == rhs.attachmentCount )
   14692           && ( pAttachments == rhs.pAttachments )
   14693           && ( subpassCount == rhs.subpassCount )
   14694           && ( pSubpasses == rhs.pSubpasses )
   14695           && ( dependencyCount == rhs.dependencyCount )
   14696           && ( pDependencies == rhs.pDependencies );
   14697     }
   14698 
   14699     bool operator!=( RenderPassCreateInfo const& rhs ) const
   14700     {
   14701       return !operator==( rhs );
   14702     }
   14703 
   14704   private:
   14705     StructureType sType;
   14706 
   14707   public:
   14708     const void* pNext;
   14709     RenderPassCreateFlags flags;
   14710     uint32_t attachmentCount;
   14711     const AttachmentDescription* pAttachments;
   14712     uint32_t subpassCount;
   14713     const SubpassDescription* pSubpasses;
   14714     uint32_t dependencyCount;
   14715     const SubpassDependency* pDependencies;
   14716   };
   14717   static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
   14718 
   14719   struct SubmitInfo
   14720   {
   14721     SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, const PipelineStageFlags* pWaitDstStageMask_ = nullptr, uint32_t commandBufferCount_ = 0, const CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
   14722       : sType( StructureType::eSubmitInfo )
   14723       , pNext( nullptr )
   14724       , waitSemaphoreCount( waitSemaphoreCount_ )
   14725       , pWaitSemaphores( pWaitSemaphores_ )
   14726       , pWaitDstStageMask( pWaitDstStageMask_ )
   14727       , commandBufferCount( commandBufferCount_ )
   14728       , pCommandBuffers( pCommandBuffers_ )
   14729       , signalSemaphoreCount( signalSemaphoreCount_ )
   14730       , pSignalSemaphores( pSignalSemaphores_ )
   14731     {
   14732     }
   14733 
   14734     SubmitInfo( VkSubmitInfo const & rhs )
   14735     {
   14736       memcpy( this, &rhs, sizeof(SubmitInfo) );
   14737     }
   14738 
   14739     SubmitInfo& operator=( VkSubmitInfo const & rhs )
   14740     {
   14741       memcpy( this, &rhs, sizeof(SubmitInfo) );
   14742       return *this;
   14743     }
   14744 
   14745     SubmitInfo& setSType( StructureType sType_ )
   14746     {
   14747       sType = sType_;
   14748       return *this;
   14749     }
   14750 
   14751     SubmitInfo& setPNext( const void* pNext_ )
   14752     {
   14753       pNext = pNext_;
   14754       return *this;
   14755     }
   14756 
   14757     SubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
   14758     {
   14759       waitSemaphoreCount = waitSemaphoreCount_;
   14760       return *this;
   14761     }
   14762 
   14763     SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
   14764     {
   14765       pWaitSemaphores = pWaitSemaphores_;
   14766       return *this;
   14767     }
   14768 
   14769     SubmitInfo& setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ )
   14770     {
   14771       pWaitDstStageMask = pWaitDstStageMask_;
   14772       return *this;
   14773     }
   14774 
   14775     SubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
   14776     {
   14777       commandBufferCount = commandBufferCount_;
   14778       return *this;
   14779     }
   14780 
   14781     SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
   14782     {
   14783       pCommandBuffers = pCommandBuffers_;
   14784       return *this;
   14785     }
   14786 
   14787     SubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
   14788     {
   14789       signalSemaphoreCount = signalSemaphoreCount_;
   14790       return *this;
   14791     }
   14792 
   14793     SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
   14794     {
   14795       pSignalSemaphores = pSignalSemaphores_;
   14796       return *this;
   14797     }
   14798 
   14799     operator const VkSubmitInfo&() const
   14800     {
   14801       return *reinterpret_cast<const VkSubmitInfo*>(this);
   14802     }
   14803 
   14804     bool operator==( SubmitInfo const& rhs ) const
   14805     {
   14806       return ( sType == rhs.sType )
   14807           && ( pNext == rhs.pNext )
   14808           && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
   14809           && ( pWaitSemaphores == rhs.pWaitSemaphores )
   14810           && ( pWaitDstStageMask == rhs.pWaitDstStageMask )
   14811           && ( commandBufferCount == rhs.commandBufferCount )
   14812           && ( pCommandBuffers == rhs.pCommandBuffers )
   14813           && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
   14814           && ( pSignalSemaphores == rhs.pSignalSemaphores );
   14815     }
   14816 
   14817     bool operator!=( SubmitInfo const& rhs ) const
   14818     {
   14819       return !operator==( rhs );
   14820     }
   14821 
   14822   private:
   14823     StructureType sType;
   14824 
   14825   public:
   14826     const void* pNext;
   14827     uint32_t waitSemaphoreCount;
   14828     const Semaphore* pWaitSemaphores;
   14829     const PipelineStageFlags* pWaitDstStageMask;
   14830     uint32_t commandBufferCount;
   14831     const CommandBuffer* pCommandBuffers;
   14832     uint32_t signalSemaphoreCount;
   14833     const Semaphore* pSignalSemaphores;
   14834   };
   14835   static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
   14836 
   14837   class Queue
   14838   {
   14839   public:
   14840     Queue()
   14841       : m_queue(VK_NULL_HANDLE)
   14842     {}
   14843 
   14844 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   14845     Queue(VkQueue queue)
   14846        : m_queue(queue)
   14847     {}
   14848 
   14849     Queue& operator=(VkQueue queue)
   14850     {
   14851       m_queue = queue;
   14852       return *this;
   14853     }
   14854 #endif
   14855 
   14856     bool operator==(Queue const &rhs) const
   14857     {
   14858       return m_queue == rhs.m_queue;
   14859     }
   14860 
   14861     bool operator!=(Queue const &rhs) const
   14862     {
   14863       return m_queue != rhs.m_queue;
   14864     }
   14865 
   14866     bool operator<(Queue const &rhs) const
   14867     {
   14868       return m_queue < rhs.m_queue;
   14869     }
   14870 
   14871     Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const
   14872     {
   14873       return static_cast<Result>( vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
   14874     }
   14875 
   14876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14877     ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence ) const
   14878     {
   14879       Result result = static_cast<Result>( vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
   14880       return createResultValue( result, "vk::Queue::submit" );
   14881     }
   14882 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14883 
   14884 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14885     Result waitIdle(  ) const
   14886     {
   14887       return static_cast<Result>( vkQueueWaitIdle( m_queue ) );
   14888     }
   14889 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14890 
   14891 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14892     ResultValueType<void>::type waitIdle() const
   14893     {
   14894       Result result = static_cast<Result>( vkQueueWaitIdle( m_queue ) );
   14895       return createResultValue( result, "vk::Queue::waitIdle" );
   14896     }
   14897 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14898 
   14899     Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence ) const
   14900     {
   14901       return static_cast<Result>( vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
   14902     }
   14903 
   14904 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14905     ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence ) const
   14906     {
   14907       Result result = static_cast<Result>( vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
   14908       return createResultValue( result, "vk::Queue::bindSparse" );
   14909     }
   14910 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14911 
   14912     Result presentKHR( const PresentInfoKHR* pPresentInfo ) const
   14913     {
   14914       return static_cast<Result>( vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
   14915     }
   14916 
   14917 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   14918     Result presentKHR( const PresentInfoKHR & presentInfo ) const
   14919     {
   14920       Result result = static_cast<Result>( vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( &presentInfo ) ) );
   14921       return createResultValue( result, "vk::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
   14922     }
   14923 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   14924 
   14925 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   14926     explicit
   14927 #endif
   14928     operator VkQueue() const
   14929     {
   14930       return m_queue;
   14931     }
   14932 
   14933     explicit operator bool() const
   14934     {
   14935       return m_queue != VK_NULL_HANDLE;
   14936     }
   14937 
   14938     bool operator!() const
   14939     {
   14940       return m_queue == VK_NULL_HANDLE;
   14941     }
   14942 
   14943   private:
   14944     VkQueue m_queue;
   14945   };
   14946   static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
   14947 
   14948   enum class PresentModeKHR
   14949   {
   14950     eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
   14951     eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
   14952     eFifo = VK_PRESENT_MODE_FIFO_KHR,
   14953     eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR
   14954   };
   14955 
   14956   enum class ColorSpaceKHR
   14957   {
   14958     eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
   14959   };
   14960 
   14961   struct SurfaceFormatKHR
   14962   {
   14963     operator const VkSurfaceFormatKHR&() const
   14964     {
   14965       return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
   14966     }
   14967 
   14968     bool operator==( SurfaceFormatKHR const& rhs ) const
   14969     {
   14970       return ( format == rhs.format )
   14971           && ( colorSpace == rhs.colorSpace );
   14972     }
   14973 
   14974     bool operator!=( SurfaceFormatKHR const& rhs ) const
   14975     {
   14976       return !operator==( rhs );
   14977     }
   14978 
   14979     Format format;
   14980     ColorSpaceKHR colorSpace;
   14981   };
   14982   static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
   14983 
   14984   enum class DisplayPlaneAlphaFlagBitsKHR
   14985   {
   14986     eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
   14987     eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
   14988     ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
   14989     ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
   14990   };
   14991 
   14992   using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
   14993 
   14994   inline DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
   14995   {
   14996     return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
   14997   }
   14998 
   14999   struct DisplayPlaneCapabilitiesKHR
   15000   {
   15001     operator const VkDisplayPlaneCapabilitiesKHR&() const
   15002     {
   15003       return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
   15004     }
   15005 
   15006     bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
   15007     {
   15008       return ( supportedAlpha == rhs.supportedAlpha )
   15009           && ( minSrcPosition == rhs.minSrcPosition )
   15010           && ( maxSrcPosition == rhs.maxSrcPosition )
   15011           && ( minSrcExtent == rhs.minSrcExtent )
   15012           && ( maxSrcExtent == rhs.maxSrcExtent )
   15013           && ( minDstPosition == rhs.minDstPosition )
   15014           && ( maxDstPosition == rhs.maxDstPosition )
   15015           && ( minDstExtent == rhs.minDstExtent )
   15016           && ( maxDstExtent == rhs.maxDstExtent );
   15017     }
   15018 
   15019     bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
   15020     {
   15021       return !operator==( rhs );
   15022     }
   15023 
   15024     DisplayPlaneAlphaFlagsKHR supportedAlpha;
   15025     Offset2D minSrcPosition;
   15026     Offset2D maxSrcPosition;
   15027     Extent2D minSrcExtent;
   15028     Extent2D maxSrcExtent;
   15029     Offset2D minDstPosition;
   15030     Offset2D maxDstPosition;
   15031     Extent2D minDstExtent;
   15032     Extent2D maxDstExtent;
   15033   };
   15034   static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
   15035 
   15036   enum class CompositeAlphaFlagBitsKHR
   15037   {
   15038     eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
   15039     ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
   15040     ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
   15041     eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
   15042   };
   15043 
   15044   using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
   15045 
   15046   inline CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
   15047   {
   15048     return CompositeAlphaFlagsKHR( bit0 ) | bit1;
   15049   }
   15050 
   15051   enum class SurfaceTransformFlagBitsKHR
   15052   {
   15053     eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
   15054     eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
   15055     eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
   15056     eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
   15057     eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
   15058     eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
   15059     eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
   15060     eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
   15061     eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
   15062   };
   15063 
   15064   using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
   15065 
   15066   inline SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
   15067   {
   15068     return SurfaceTransformFlagsKHR( bit0 ) | bit1;
   15069   }
   15070 
   15071   struct DisplayPropertiesKHR
   15072   {
   15073     operator const VkDisplayPropertiesKHR&() const
   15074     {
   15075       return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
   15076     }
   15077 
   15078     bool operator==( DisplayPropertiesKHR const& rhs ) const
   15079     {
   15080       return ( display == rhs.display )
   15081           && ( displayName == rhs.displayName )
   15082           && ( physicalDimensions == rhs.physicalDimensions )
   15083           && ( physicalResolution == rhs.physicalResolution )
   15084           && ( supportedTransforms == rhs.supportedTransforms )
   15085           && ( planeReorderPossible == rhs.planeReorderPossible )
   15086           && ( persistentContent == rhs.persistentContent );
   15087     }
   15088 
   15089     bool operator!=( DisplayPropertiesKHR const& rhs ) const
   15090     {
   15091       return !operator==( rhs );
   15092     }
   15093 
   15094     DisplayKHR display;
   15095     const char* displayName;
   15096     Extent2D physicalDimensions;
   15097     Extent2D physicalResolution;
   15098     SurfaceTransformFlagsKHR supportedTransforms;
   15099     Bool32 planeReorderPossible;
   15100     Bool32 persistentContent;
   15101   };
   15102   static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
   15103 
   15104   struct DisplaySurfaceCreateInfoKHR
   15105   {
   15106     DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() )
   15107       : sType( StructureType::eDisplaySurfaceCreateInfoKHR )
   15108       , pNext( nullptr )
   15109       , flags( flags_ )
   15110       , displayMode( displayMode_ )
   15111       , planeIndex( planeIndex_ )
   15112       , planeStackIndex( planeStackIndex_ )
   15113       , transform( transform_ )
   15114       , globalAlpha( globalAlpha_ )
   15115       , alphaMode( alphaMode_ )
   15116       , imageExtent( imageExtent_ )
   15117     {
   15118     }
   15119 
   15120     DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
   15121     {
   15122       memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
   15123     }
   15124 
   15125     DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
   15126     {
   15127       memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
   15128       return *this;
   15129     }
   15130 
   15131     DisplaySurfaceCreateInfoKHR& setSType( StructureType sType_ )
   15132     {
   15133       sType = sType_;
   15134       return *this;
   15135     }
   15136 
   15137     DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
   15138     {
   15139       pNext = pNext_;
   15140       return *this;
   15141     }
   15142 
   15143     DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
   15144     {
   15145       flags = flags_;
   15146       return *this;
   15147     }
   15148 
   15149     DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
   15150     {
   15151       displayMode = displayMode_;
   15152       return *this;
   15153     }
   15154 
   15155     DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
   15156     {
   15157       planeIndex = planeIndex_;
   15158       return *this;
   15159     }
   15160 
   15161     DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
   15162     {
   15163       planeStackIndex = planeStackIndex_;
   15164       return *this;
   15165     }
   15166 
   15167     DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
   15168     {
   15169       transform = transform_;
   15170       return *this;
   15171     }
   15172 
   15173     DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
   15174     {
   15175       globalAlpha = globalAlpha_;
   15176       return *this;
   15177     }
   15178 
   15179     DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
   15180     {
   15181       alphaMode = alphaMode_;
   15182       return *this;
   15183     }
   15184 
   15185     DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
   15186     {
   15187       imageExtent = imageExtent_;
   15188       return *this;
   15189     }
   15190 
   15191     operator const VkDisplaySurfaceCreateInfoKHR&() const
   15192     {
   15193       return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
   15194     }
   15195 
   15196     bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
   15197     {
   15198       return ( sType == rhs.sType )
   15199           && ( pNext == rhs.pNext )
   15200           && ( flags == rhs.flags )
   15201           && ( displayMode == rhs.displayMode )
   15202           && ( planeIndex == rhs.planeIndex )
   15203           && ( planeStackIndex == rhs.planeStackIndex )
   15204           && ( transform == rhs.transform )
   15205           && ( globalAlpha == rhs.globalAlpha )
   15206           && ( alphaMode == rhs.alphaMode )
   15207           && ( imageExtent == rhs.imageExtent );
   15208     }
   15209 
   15210     bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
   15211     {
   15212       return !operator==( rhs );
   15213     }
   15214 
   15215   private:
   15216     StructureType sType;
   15217 
   15218   public:
   15219     const void* pNext;
   15220     DisplaySurfaceCreateFlagsKHR flags;
   15221     DisplayModeKHR displayMode;
   15222     uint32_t planeIndex;
   15223     uint32_t planeStackIndex;
   15224     SurfaceTransformFlagBitsKHR transform;
   15225     float globalAlpha;
   15226     DisplayPlaneAlphaFlagBitsKHR alphaMode;
   15227     Extent2D imageExtent;
   15228   };
   15229   static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
   15230 
   15231   struct SurfaceCapabilitiesKHR
   15232   {
   15233     operator const VkSurfaceCapabilitiesKHR&() const
   15234     {
   15235       return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
   15236     }
   15237 
   15238     bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
   15239     {
   15240       return ( minImageCount == rhs.minImageCount )
   15241           && ( maxImageCount == rhs.maxImageCount )
   15242           && ( currentExtent == rhs.currentExtent )
   15243           && ( minImageExtent == rhs.minImageExtent )
   15244           && ( maxImageExtent == rhs.maxImageExtent )
   15245           && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
   15246           && ( supportedTransforms == rhs.supportedTransforms )
   15247           && ( currentTransform == rhs.currentTransform )
   15248           && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
   15249           && ( supportedUsageFlags == rhs.supportedUsageFlags );
   15250     }
   15251 
   15252     bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
   15253     {
   15254       return !operator==( rhs );
   15255     }
   15256 
   15257     uint32_t minImageCount;
   15258     uint32_t maxImageCount;
   15259     Extent2D currentExtent;
   15260     Extent2D minImageExtent;
   15261     Extent2D maxImageExtent;
   15262     uint32_t maxImageArrayLayers;
   15263     SurfaceTransformFlagsKHR supportedTransforms;
   15264     SurfaceTransformFlagBitsKHR currentTransform;
   15265     CompositeAlphaFlagsKHR supportedCompositeAlpha;
   15266     ImageUsageFlags supportedUsageFlags;
   15267   };
   15268   static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
   15269 
   15270   struct SwapchainCreateInfoKHR
   15271   {
   15272     SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), SurfaceKHR surface_ = SurfaceKHR(), uint32_t minImageCount_ = 0, Format imageFormat_ = Format::eUndefined, ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, Extent2D imageExtent_ = Extent2D(), uint32_t imageArrayLayers_ = 0, ImageUsageFlags imageUsage_ = ImageUsageFlags(), SharingMode imageSharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, Bool32 clipped_ = 0, SwapchainKHR oldSwapchain_ = SwapchainKHR() )
   15273       : sType( StructureType::eSwapchainCreateInfoKHR )
   15274       , pNext( nullptr )
   15275       , flags( flags_ )
   15276       , surface( surface_ )
   15277       , minImageCount( minImageCount_ )
   15278       , imageFormat( imageFormat_ )
   15279       , imageColorSpace( imageColorSpace_ )
   15280       , imageExtent( imageExtent_ )
   15281       , imageArrayLayers( imageArrayLayers_ )
   15282       , imageUsage( imageUsage_ )
   15283       , imageSharingMode( imageSharingMode_ )
   15284       , queueFamilyIndexCount( queueFamilyIndexCount_ )
   15285       , pQueueFamilyIndices( pQueueFamilyIndices_ )
   15286       , preTransform( preTransform_ )
   15287       , compositeAlpha( compositeAlpha_ )
   15288       , presentMode( presentMode_ )
   15289       , clipped( clipped_ )
   15290       , oldSwapchain( oldSwapchain_ )
   15291     {
   15292     }
   15293 
   15294     SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
   15295     {
   15296       memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
   15297     }
   15298 
   15299     SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
   15300     {
   15301       memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
   15302       return *this;
   15303     }
   15304 
   15305     SwapchainCreateInfoKHR& setSType( StructureType sType_ )
   15306     {
   15307       sType = sType_;
   15308       return *this;
   15309     }
   15310 
   15311     SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
   15312     {
   15313       pNext = pNext_;
   15314       return *this;
   15315     }
   15316 
   15317     SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
   15318     {
   15319       flags = flags_;
   15320       return *this;
   15321     }
   15322 
   15323     SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
   15324     {
   15325       surface = surface_;
   15326       return *this;
   15327     }
   15328 
   15329     SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
   15330     {
   15331       minImageCount = minImageCount_;
   15332       return *this;
   15333     }
   15334 
   15335     SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
   15336     {
   15337       imageFormat = imageFormat_;
   15338       return *this;
   15339     }
   15340 
   15341     SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
   15342     {
   15343       imageColorSpace = imageColorSpace_;
   15344       return *this;
   15345     }
   15346 
   15347     SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
   15348     {
   15349       imageExtent = imageExtent_;
   15350       return *this;
   15351     }
   15352 
   15353     SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
   15354     {
   15355       imageArrayLayers = imageArrayLayers_;
   15356       return *this;
   15357     }
   15358 
   15359     SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
   15360     {
   15361       imageUsage = imageUsage_;
   15362       return *this;
   15363     }
   15364 
   15365     SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
   15366     {
   15367       imageSharingMode = imageSharingMode_;
   15368       return *this;
   15369     }
   15370 
   15371     SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
   15372     {
   15373       queueFamilyIndexCount = queueFamilyIndexCount_;
   15374       return *this;
   15375     }
   15376 
   15377     SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
   15378     {
   15379       pQueueFamilyIndices = pQueueFamilyIndices_;
   15380       return *this;
   15381     }
   15382 
   15383     SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
   15384     {
   15385       preTransform = preTransform_;
   15386       return *this;
   15387     }
   15388 
   15389     SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
   15390     {
   15391       compositeAlpha = compositeAlpha_;
   15392       return *this;
   15393     }
   15394 
   15395     SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
   15396     {
   15397       presentMode = presentMode_;
   15398       return *this;
   15399     }
   15400 
   15401     SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
   15402     {
   15403       clipped = clipped_;
   15404       return *this;
   15405     }
   15406 
   15407     SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
   15408     {
   15409       oldSwapchain = oldSwapchain_;
   15410       return *this;
   15411     }
   15412 
   15413     operator const VkSwapchainCreateInfoKHR&() const
   15414     {
   15415       return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
   15416     }
   15417 
   15418     bool operator==( SwapchainCreateInfoKHR const& rhs ) const
   15419     {
   15420       return ( sType == rhs.sType )
   15421           && ( pNext == rhs.pNext )
   15422           && ( flags == rhs.flags )
   15423           && ( surface == rhs.surface )
   15424           && ( minImageCount == rhs.minImageCount )
   15425           && ( imageFormat == rhs.imageFormat )
   15426           && ( imageColorSpace == rhs.imageColorSpace )
   15427           && ( imageExtent == rhs.imageExtent )
   15428           && ( imageArrayLayers == rhs.imageArrayLayers )
   15429           && ( imageUsage == rhs.imageUsage )
   15430           && ( imageSharingMode == rhs.imageSharingMode )
   15431           && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
   15432           && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
   15433           && ( preTransform == rhs.preTransform )
   15434           && ( compositeAlpha == rhs.compositeAlpha )
   15435           && ( presentMode == rhs.presentMode )
   15436           && ( clipped == rhs.clipped )
   15437           && ( oldSwapchain == rhs.oldSwapchain );
   15438     }
   15439 
   15440     bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
   15441     {
   15442       return !operator==( rhs );
   15443     }
   15444 
   15445   private:
   15446     StructureType sType;
   15447 
   15448   public:
   15449     const void* pNext;
   15450     SwapchainCreateFlagsKHR flags;
   15451     SurfaceKHR surface;
   15452     uint32_t minImageCount;
   15453     Format imageFormat;
   15454     ColorSpaceKHR imageColorSpace;
   15455     Extent2D imageExtent;
   15456     uint32_t imageArrayLayers;
   15457     ImageUsageFlags imageUsage;
   15458     SharingMode imageSharingMode;
   15459     uint32_t queueFamilyIndexCount;
   15460     const uint32_t* pQueueFamilyIndices;
   15461     SurfaceTransformFlagBitsKHR preTransform;
   15462     CompositeAlphaFlagBitsKHR compositeAlpha;
   15463     PresentModeKHR presentMode;
   15464     Bool32 clipped;
   15465     SwapchainKHR oldSwapchain;
   15466   };
   15467   static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
   15468 
   15469   enum class DebugReportFlagBitsEXT
   15470   {
   15471     eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
   15472     eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
   15473     ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
   15474     eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
   15475     eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
   15476   };
   15477 
   15478   using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
   15479 
   15480   inline DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
   15481   {
   15482     return DebugReportFlagsEXT( bit0 ) | bit1;
   15483   }
   15484 
   15485   struct DebugReportCallbackCreateInfoEXT
   15486   {
   15487     DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr )
   15488       : sType( StructureType::eDebugReportCallbackCreateInfoEXT )
   15489       , pNext( nullptr )
   15490       , flags( flags_ )
   15491       , pfnCallback( pfnCallback_ )
   15492       , pUserData( pUserData_ )
   15493     {
   15494     }
   15495 
   15496     DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
   15497     {
   15498       memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
   15499     }
   15500 
   15501     DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
   15502     {
   15503       memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
   15504       return *this;
   15505     }
   15506 
   15507     DebugReportCallbackCreateInfoEXT& setSType( StructureType sType_ )
   15508     {
   15509       sType = sType_;
   15510       return *this;
   15511     }
   15512 
   15513     DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
   15514     {
   15515       pNext = pNext_;
   15516       return *this;
   15517     }
   15518 
   15519     DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
   15520     {
   15521       flags = flags_;
   15522       return *this;
   15523     }
   15524 
   15525     DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
   15526     {
   15527       pfnCallback = pfnCallback_;
   15528       return *this;
   15529     }
   15530 
   15531     DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
   15532     {
   15533       pUserData = pUserData_;
   15534       return *this;
   15535     }
   15536 
   15537     operator const VkDebugReportCallbackCreateInfoEXT&() const
   15538     {
   15539       return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
   15540     }
   15541 
   15542     bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
   15543     {
   15544       return ( sType == rhs.sType )
   15545           && ( pNext == rhs.pNext )
   15546           && ( flags == rhs.flags )
   15547           && ( pfnCallback == rhs.pfnCallback )
   15548           && ( pUserData == rhs.pUserData );
   15549     }
   15550 
   15551     bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
   15552     {
   15553       return !operator==( rhs );
   15554     }
   15555 
   15556   private:
   15557     StructureType sType;
   15558 
   15559   public:
   15560     const void* pNext;
   15561     DebugReportFlagsEXT flags;
   15562     PFN_vkDebugReportCallbackEXT pfnCallback;
   15563     void* pUserData;
   15564   };
   15565   static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
   15566 
   15567   enum class DebugReportObjectTypeEXT
   15568   {
   15569     eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
   15570     eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
   15571     ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
   15572     eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
   15573     eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
   15574     eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
   15575     eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
   15576     eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
   15577     eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
   15578     eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
   15579     eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
   15580     eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
   15581     eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
   15582     eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
   15583     eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
   15584     eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
   15585     ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
   15586     ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
   15587     eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
   15588     ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
   15589     eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
   15590     eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
   15591     eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
   15592     eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
   15593     eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
   15594     eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
   15595     eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
   15596     eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
   15597     eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT
   15598   };
   15599 
   15600   struct DebugMarkerObjectNameInfoEXT
   15601   {
   15602     DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr )
   15603       : sType( StructureType::eDebugMarkerObjectNameInfoEXT )
   15604       , pNext( nullptr )
   15605       , objectType( objectType_ )
   15606       , object( object_ )
   15607       , pObjectName( pObjectName_ )
   15608     {
   15609     }
   15610 
   15611     DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
   15612     {
   15613       memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
   15614     }
   15615 
   15616     DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
   15617     {
   15618       memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
   15619       return *this;
   15620     }
   15621 
   15622     DebugMarkerObjectNameInfoEXT& setSType( StructureType sType_ )
   15623     {
   15624       sType = sType_;
   15625       return *this;
   15626     }
   15627 
   15628     DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
   15629     {
   15630       pNext = pNext_;
   15631       return *this;
   15632     }
   15633 
   15634     DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
   15635     {
   15636       objectType = objectType_;
   15637       return *this;
   15638     }
   15639 
   15640     DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
   15641     {
   15642       object = object_;
   15643       return *this;
   15644     }
   15645 
   15646     DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
   15647     {
   15648       pObjectName = pObjectName_;
   15649       return *this;
   15650     }
   15651 
   15652     operator const VkDebugMarkerObjectNameInfoEXT&() const
   15653     {
   15654       return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
   15655     }
   15656 
   15657     bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
   15658     {
   15659       return ( sType == rhs.sType )
   15660           && ( pNext == rhs.pNext )
   15661           && ( objectType == rhs.objectType )
   15662           && ( object == rhs.object )
   15663           && ( pObjectName == rhs.pObjectName );
   15664     }
   15665 
   15666     bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
   15667     {
   15668       return !operator==( rhs );
   15669     }
   15670 
   15671   private:
   15672     StructureType sType;
   15673 
   15674   public:
   15675     const void* pNext;
   15676     DebugReportObjectTypeEXT objectType;
   15677     uint64_t object;
   15678     const char* pObjectName;
   15679   };
   15680   static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
   15681 
   15682   struct DebugMarkerObjectTagInfoEXT
   15683   {
   15684     DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr )
   15685       : sType( StructureType::eDebugMarkerObjectTagInfoEXT )
   15686       , pNext( nullptr )
   15687       , objectType( objectType_ )
   15688       , object( object_ )
   15689       , tagName( tagName_ )
   15690       , tagSize( tagSize_ )
   15691       , pTag( pTag_ )
   15692     {
   15693     }
   15694 
   15695     DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
   15696     {
   15697       memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
   15698     }
   15699 
   15700     DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
   15701     {
   15702       memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
   15703       return *this;
   15704     }
   15705 
   15706     DebugMarkerObjectTagInfoEXT& setSType( StructureType sType_ )
   15707     {
   15708       sType = sType_;
   15709       return *this;
   15710     }
   15711 
   15712     DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
   15713     {
   15714       pNext = pNext_;
   15715       return *this;
   15716     }
   15717 
   15718     DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
   15719     {
   15720       objectType = objectType_;
   15721       return *this;
   15722     }
   15723 
   15724     DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
   15725     {
   15726       object = object_;
   15727       return *this;
   15728     }
   15729 
   15730     DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
   15731     {
   15732       tagName = tagName_;
   15733       return *this;
   15734     }
   15735 
   15736     DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
   15737     {
   15738       tagSize = tagSize_;
   15739       return *this;
   15740     }
   15741 
   15742     DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
   15743     {
   15744       pTag = pTag_;
   15745       return *this;
   15746     }
   15747 
   15748     operator const VkDebugMarkerObjectTagInfoEXT&() const
   15749     {
   15750       return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
   15751     }
   15752 
   15753     bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
   15754     {
   15755       return ( sType == rhs.sType )
   15756           && ( pNext == rhs.pNext )
   15757           && ( objectType == rhs.objectType )
   15758           && ( object == rhs.object )
   15759           && ( tagName == rhs.tagName )
   15760           && ( tagSize == rhs.tagSize )
   15761           && ( pTag == rhs.pTag );
   15762     }
   15763 
   15764     bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
   15765     {
   15766       return !operator==( rhs );
   15767     }
   15768 
   15769   private:
   15770     StructureType sType;
   15771 
   15772   public:
   15773     const void* pNext;
   15774     DebugReportObjectTypeEXT objectType;
   15775     uint64_t object;
   15776     uint64_t tagName;
   15777     size_t tagSize;
   15778     const void* pTag;
   15779   };
   15780   static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
   15781 
   15782   enum class DebugReportErrorEXT
   15783   {
   15784     eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT,
   15785     eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT
   15786   };
   15787 
   15788   enum class RasterizationOrderAMD
   15789   {
   15790     eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
   15791     eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
   15792   };
   15793 
   15794   struct PipelineRasterizationStateRasterizationOrderAMD
   15795   {
   15796     PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
   15797       : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD )
   15798       , pNext( nullptr )
   15799       , rasterizationOrder( rasterizationOrder_ )
   15800     {
   15801     }
   15802 
   15803     PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
   15804     {
   15805       memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
   15806     }
   15807 
   15808     PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
   15809     {
   15810       memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
   15811       return *this;
   15812     }
   15813 
   15814     PipelineRasterizationStateRasterizationOrderAMD& setSType( StructureType sType_ )
   15815     {
   15816       sType = sType_;
   15817       return *this;
   15818     }
   15819 
   15820     PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
   15821     {
   15822       pNext = pNext_;
   15823       return *this;
   15824     }
   15825 
   15826     PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
   15827     {
   15828       rasterizationOrder = rasterizationOrder_;
   15829       return *this;
   15830     }
   15831 
   15832     operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
   15833     {
   15834       return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
   15835     }
   15836 
   15837     bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
   15838     {
   15839       return ( sType == rhs.sType )
   15840           && ( pNext == rhs.pNext )
   15841           && ( rasterizationOrder == rhs.rasterizationOrder );
   15842     }
   15843 
   15844     bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
   15845     {
   15846       return !operator==( rhs );
   15847     }
   15848 
   15849   private:
   15850     StructureType sType;
   15851 
   15852   public:
   15853     const void* pNext;
   15854     RasterizationOrderAMD rasterizationOrder;
   15855   };
   15856   static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
   15857 
   15858   enum class ExternalMemoryHandleTypeFlagBitsNV
   15859   {
   15860     eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
   15861     eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
   15862     eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
   15863     eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
   15864   };
   15865 
   15866   using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
   15867 
   15868   inline ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
   15869   {
   15870     return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
   15871   }
   15872 
   15873   class Device
   15874   {
   15875     eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT,
   15876     eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT
   15877   };
   15878 
   15879   enum class RasterizationOrderAMD
   15880   {
   15881     eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
   15882     eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
   15883   };
   15884 
   15885   struct PipelineRasterizationStateRasterizationOrderAMD
   15886   {
   15887     PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
   15888       : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD )
   15889       , pNext( nullptr )
   15890       , rasterizationOrder( rasterizationOrder_ )
   15891     {
   15892     }
   15893 
   15894     bool operator==(Device const &rhs) const
   15895     {
   15896       return m_device == rhs.m_device;
   15897     }
   15898 
   15899     bool operator!=(Device const &rhs) const
   15900     {
   15901       return m_device != rhs.m_device;
   15902     }
   15903 
   15904     bool operator<(Device const &rhs) const
   15905     {
   15906       return m_device < rhs.m_device;
   15907     }
   15908 
   15909     PFN_vkVoidFunction getProcAddr( const char* pName ) const
   15910     {
   15911       memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
   15912     }
   15913 
   15914     PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
   15915     {
   15916       memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
   15917       return *this;
   15918     }
   15919 
   15920     PipelineRasterizationStateRasterizationOrderAMD& setSType( StructureType sType_ )
   15921     {
   15922       sType = sType_;
   15923       return *this;
   15924     }
   15925 
   15926     PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
   15927     {
   15928       pNext = pNext_;
   15929       return *this;
   15930     }
   15931 
   15932     PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
   15933     {
   15934       rasterizationOrder = rasterizationOrder_;
   15935       return *this;
   15936     }
   15937 
   15938     operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
   15939     {
   15940       return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
   15941     }
   15942 
   15943     bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
   15944     {
   15945       return ( sType == rhs.sType )
   15946           && ( pNext == rhs.pNext )
   15947           && ( rasterizationOrder == rhs.rasterizationOrder );
   15948     }
   15949 
   15950     bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
   15951     {
   15952       return !operator==( rhs );
   15953     }
   15954 
   15955   private:
   15956     StructureType sType;
   15957 
   15958   public:
   15959     const void* pNext;
   15960     RasterizationOrderAMD rasterizationOrder;
   15961   };
   15962   static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
   15963 
   15964   enum class ExternalMemoryHandleTypeFlagBitsNV
   15965   {
   15966     eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
   15967     eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
   15968     eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
   15969     eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
   15970   };
   15971 
   15972   using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
   15973 
   15974   inline ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
   15975   {
   15976     return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
   15977   }
   15978 
   15979   class Device
   15980   {
   15981   public:
   15982     Device()
   15983       : m_device(VK_NULL_HANDLE)
   15984     {}
   15985 
   15986 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   15987     Device(VkDevice device)
   15988        : m_device(device)
   15989     {}
   15990 
   15991     Device& operator=(VkDevice device)
   15992     {
   15993       m_device = device;
   15994       return *this;
   15995     }
   15996 #endif
   15997 
   15998     bool operator==(Device const &rhs) const
   15999     {
   16000       return m_device == rhs.m_device;
   16001     }
   16002 
   16003     bool operator!=(Device const &rhs) const
   16004     {
   16005       return m_device != rhs.m_device;
   16006     }
   16007 
   16008     bool operator<(Device const &rhs) const
   16009     {
   16010       return m_device < rhs.m_device;
   16011     }
   16012 
   16013     PFN_vkVoidFunction getProcAddr( const char* pName ) const
   16014     {
   16015       return vkGetDeviceProcAddr( m_device, pName );
   16016     }
   16017 
   16018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16019     PFN_vkVoidFunction getProcAddr( const std::string & name ) const
   16020     {
   16021       return vkGetDeviceProcAddr( m_device, name.c_str() );
   16022     }
   16023 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16024 
   16025     void destroy( const AllocationCallbacks* pAllocator ) const
   16026     {
   16027       vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16028     }
   16029 
   16030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16031     void destroy( Optional<const AllocationCallbacks> allocator = nullptr ) const
   16032     {
   16033       vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16034     }
   16035 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16036 
   16037     void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue ) const
   16038     {
   16039       vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
   16040     }
   16041 
   16042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16043     Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const
   16044     {
   16045       Queue queue;
   16046       vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
   16047       return queue;
   16048     }
   16049 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16050 
   16051 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16052     Result waitIdle(  ) const
   16053     {
   16054       return static_cast<Result>( vkDeviceWaitIdle( m_device ) );
   16055     }
   16056 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16057 
   16058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16059     ResultValueType<void>::type waitIdle() const
   16060     {
   16061       Result result = static_cast<Result>( vkDeviceWaitIdle( m_device ) );
   16062       return createResultValue( result, "vk::Device::waitIdle" );
   16063     }
   16064 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16065 
   16066     Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory ) const
   16067     {
   16068       return static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( pAllocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDeviceMemory*>( pMemory ) ) );
   16069     }
   16070 
   16071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16072     ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16073     {
   16074       DeviceMemory memory;
   16075       Result result = static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
   16076       return createResultValue( result, memory, "vk::Device::allocateMemory" );
   16077     }
   16078 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16079 
   16080     void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator ) const
   16081     {
   16082       vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16083     }
   16084 
   16085 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16086     void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16087     {
   16088       vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16089     }
   16090 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16091 
   16092 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16093     Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData ) const
   16094     {
   16095       return static_cast<Result>( vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), ppData ) );
   16096     }
   16097 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16098 
   16099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16100     ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags() ) const
   16101     {
   16102       void* pData;
   16103       Result result = static_cast<Result>( vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), &pData ) );
   16104       return createResultValue( result, pData, "vk::Device::mapMemory" );
   16105     }
   16106 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16107 
   16108 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16109     void unmapMemory( DeviceMemory memory ) const
   16110     {
   16111       vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   16112     }
   16113 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16114 
   16115 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16116     void unmapMemory( DeviceMemory memory ) const
   16117     {
   16118       vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   16119     }
   16120 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16121 
   16122     Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const
   16123     {
   16124       return static_cast<Result>( vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
   16125     }
   16126 
   16127 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16128     ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const
   16129     {
   16130       Result result = static_cast<Result>( vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
   16131       return createResultValue( result, "vk::Device::flushMappedMemoryRanges" );
   16132     }
   16133 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16134 
   16135     Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const
   16136     {
   16137       return static_cast<Result>( vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
   16138     }
   16139 
   16140 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16141     ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const
   16142     {
   16143       Result result = static_cast<Result>( vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
   16144       return createResultValue( result, "vk::Device::invalidateMappedMemoryRanges" );
   16145     }
   16146 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16147 
   16148     void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes ) const
   16149     {
   16150       vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), pCommittedMemoryInBytes );
   16151     }
   16152 
   16153 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16154     DeviceSize getMemoryCommitment( DeviceMemory memory ) const
   16155     {
   16156       DeviceSize committedMemoryInBytes;
   16157       vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), &committedMemoryInBytes );
   16158       return committedMemoryInBytes;
   16159     }
   16160 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16161 
   16162     void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements ) const
   16163     {
   16164       vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
   16165     }
   16166 
   16167 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16168     MemoryRequirements getBufferMemoryRequirements( Buffer buffer ) const
   16169     {
   16170       MemoryRequirements memoryRequirements;
   16171       vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
   16172       return memoryRequirements;
   16173     }
   16174 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16175 
   16176 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16177     Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const
   16178     {
   16179       return static_cast<Result>( vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
   16180     }
   16181 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16182 
   16183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16184     ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const
   16185     {
   16186       Result result = static_cast<Result>( vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
   16187       return createResultValue( result, "vk::Device::bindBufferMemory" );
   16188     }
   16189 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16190 
   16191     void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements ) const
   16192     {
   16193       vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
   16194     }
   16195 
   16196 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16197     MemoryRequirements getImageMemoryRequirements( Image image ) const
   16198     {
   16199       MemoryRequirements memoryRequirements;
   16200       vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
   16201       return memoryRequirements;
   16202     }
   16203 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16204 
   16205 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16206     Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const
   16207     {
   16208       return static_cast<Result>( vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
   16209     }
   16210 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16211 
   16212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16213     ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const
   16214     {
   16215       Result result = static_cast<Result>( vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
   16216       return createResultValue( result, "vk::Device::bindImageMemory" );
   16217     }
   16218 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16219 
   16220     void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) const
   16221     {
   16222       vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
   16223     }
   16224 
   16225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16226     template <typename Allocator = std::allocator<SparseImageMemoryRequirements>>
   16227     std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image ) const
   16228     {
   16229       std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
   16230       uint32_t sparseMemoryRequirementCount;
   16231       vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
   16232       sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
   16233       vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
   16234       return sparseMemoryRequirements;
   16235     }
   16236 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16237 
   16238     Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const
   16239     {
   16240       return static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
   16241     }
   16242 
   16243 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16244     ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16245     {
   16246       Fence fence;
   16247       Result result = static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkFence*>( &fence ) ) );
   16248       return createResultValue( result, fence, "vk::Device::createFence" );
   16249     }
   16250 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16251 
   16252     void destroyFence( Fence fence, const AllocationCallbacks* pAllocator ) const
   16253     {
   16254       vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16255     }
   16256 
   16257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16258     void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16259     {
   16260       vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16261     }
   16262 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16263 
   16264     Result resetFences( uint32_t fenceCount, const Fence* pFences ) const
   16265     {
   16266       return static_cast<Result>( vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
   16267     }
   16268 
   16269 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16270     ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences ) const
   16271     {
   16272       Result result = static_cast<Result>( vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
   16273       return createResultValue( result, "vk::Device::resetFences" );
   16274     }
   16275 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16276 
   16277 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16278     Result getFenceStatus( Fence fence ) const
   16279     {
   16280       return static_cast<Result>( vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
   16281     }
   16282 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16283 
   16284 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16285     Result getFenceStatus( Fence fence ) const
   16286     {
   16287       Result result = static_cast<Result>( vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
   16288       return createResultValue( result, "vk::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
   16289     }
   16290 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16291 
   16292     Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout ) const
   16293     {
   16294       return static_cast<Result>( vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), waitAll, timeout ) );
   16295     }
   16296 
   16297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16298     Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout ) const
   16299     {
   16300       Result result = static_cast<Result>( vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), waitAll, timeout ) );
   16301       return createResultValue( result, "vk::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
   16302     }
   16303 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16304 
   16305     Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore ) const
   16306     {
   16307       return static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
   16308     }
   16309 
   16310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16311     ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16312     {
   16313       Semaphore semaphore;
   16314       Result result = static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
   16315       return createResultValue( result, semaphore, "vk::Device::createSemaphore" );
   16316     }
   16317 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16318 
   16319     void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator ) const
   16320     {
   16321       vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16322     }
   16323 
   16324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16325     void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16326     {
   16327       vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16328     }
   16329 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16330 
   16331     Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent ) const
   16332     {
   16333       return static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
   16334     }
   16335 
   16336 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16337     ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16338     {
   16339       Event event;
   16340       Result result = static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkEvent*>( &event ) ) );
   16341       return createResultValue( result, event, "vk::Device::createEvent" );
   16342     }
   16343 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16344 
   16345     void destroyEvent( Event event, const AllocationCallbacks* pAllocator ) const
   16346     {
   16347       vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16348     }
   16349 
   16350 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16351     void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16352     {
   16353       vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16354     }
   16355 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16356 
   16357 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16358     Result getEventStatus( Event event ) const
   16359     {
   16360       return static_cast<Result>( vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
   16361     }
   16362 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16363 
   16364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16365     Result getEventStatus( Event event ) const
   16366     {
   16367       Result result = static_cast<Result>( vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
   16368       return createResultValue( result, "vk::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
   16369     }
   16370 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16371 
   16372 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16373     Result setEvent( Event event ) const
   16374     {
   16375       return static_cast<Result>( vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
   16376     }
   16377 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16378 
   16379 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16380     ResultValueType<void>::type setEvent( Event event ) const
   16381     {
   16382       Result result = static_cast<Result>( vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
   16383       return createResultValue( result, "vk::Device::setEvent" );
   16384     }
   16385 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16386 
   16387 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16388     Result resetEvent( Event event ) const
   16389     {
   16390       return static_cast<Result>( vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
   16391     }
   16392 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16393 
   16394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16395     ResultValueType<void>::type resetEvent( Event event ) const
   16396     {
   16397       Result result = static_cast<Result>( vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
   16398       return createResultValue( result, "vk::Device::resetEvent" );
   16399     }
   16400 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16401 
   16402     Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool ) const
   16403     {
   16404       return static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
   16405     }
   16406 
   16407 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16408     ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16409     {
   16410       QueryPool queryPool;
   16411       Result result = static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
   16412       return createResultValue( result, queryPool, "vk::Device::createQueryPool" );
   16413     }
   16414 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16415 
   16416     void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator ) const
   16417     {
   16418       vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16419     }
   16420 
   16421 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16422     void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16423     {
   16424       vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16425     }
   16426 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16427 
   16428     Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags ) const
   16429     {
   16430       return static_cast<Result>( vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast<VkQueryResultFlags>( flags ) ) );
   16431     }
   16432 
   16433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16434     template <typename T>
   16435     Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags ) const
   16436     {
   16437       Result result = static_cast<Result>( vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), stride, static_cast<VkQueryResultFlags>( flags ) ) );
   16438       return createResultValue( result, "vk::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
   16439     }
   16440 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16441 
   16442     Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer ) const
   16443     {
   16444       return static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
   16445     }
   16446 
   16447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16448     ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16449     {
   16450       Buffer buffer;
   16451       Result result = static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkBuffer*>( &buffer ) ) );
   16452       return createResultValue( result, buffer, "vk::Device::createBuffer" );
   16453     }
   16454 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16455 
   16456     void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator ) const
   16457     {
   16458       vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16459     }
   16460 
   16461 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16462     void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16463     {
   16464       vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16465     }
   16466 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16467 
   16468     Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView ) const
   16469     {
   16470       return static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
   16471     }
   16472 
   16473 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16474     ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16475     {
   16476       BufferView view;
   16477       Result result = static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkBufferView*>( &view ) ) );
   16478       return createResultValue( result, view, "vk::Device::createBufferView" );
   16479     }
   16480 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16481 
   16482     void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator ) const
   16483     {
   16484       vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16485     }
   16486 
   16487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16488     void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16489     {
   16490       vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16491     }
   16492 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16493 
   16494     Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage ) const
   16495     {
   16496       return static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
   16497     }
   16498 
   16499 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16500     ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16501     {
   16502       Image image;
   16503       Result result = static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkImage*>( &image ) ) );
   16504       return createResultValue( result, image, "vk::Device::createImage" );
   16505     }
   16506 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16507 
   16508     void destroyImage( Image image, const AllocationCallbacks* pAllocator ) const
   16509     {
   16510       vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16511     }
   16512 
   16513 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16514     void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16515     {
   16516       vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16517     }
   16518 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16519 
   16520     void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout ) const
   16521     {
   16522       vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
   16523     }
   16524 
   16525 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16526     SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource ) const
   16527     {
   16528       SubresourceLayout layout;
   16529       vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
   16530       return layout;
   16531     }
   16532 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16533 
   16534     Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView ) const
   16535     {
   16536       return static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
   16537     }
   16538 
   16539 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16540     ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16541     {
   16542       ImageView view;
   16543       Result result = static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkImageView*>( &view ) ) );
   16544       return createResultValue( result, view, "vk::Device::createImageView" );
   16545     }
   16546 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16547 
   16548     void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator ) const
   16549     {
   16550       vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16551     }
   16552 
   16553 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16554     void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16555     {
   16556       vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16557     }
   16558 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16559 
   16560     Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule ) const
   16561     {
   16562       return static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
   16563     }
   16564 
   16565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16566     ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16567     {
   16568       ShaderModule shaderModule;
   16569       Result result = static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
   16570       return createResultValue( result, shaderModule, "vk::Device::createShaderModule" );
   16571     }
   16572 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16573 
   16574     void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator ) const
   16575     {
   16576       vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16577     }
   16578 
   16579 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16580     void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16581     {
   16582       vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16583     }
   16584 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16585 
   16586     Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache ) const
   16587     {
   16588       return static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
   16589     }
   16590 
   16591 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16592     ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16593     {
   16594       PipelineCache pipelineCache;
   16595       Result result = static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
   16596       return createResultValue( result, pipelineCache, "vk::Device::createPipelineCache" );
   16597     }
   16598 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16599 
   16600     void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator ) const
   16601     {
   16602       vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16603     }
   16604 
   16605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16606     void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16607     {
   16608       vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16609     }
   16610 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16611 
   16612     Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData ) const
   16613     {
   16614       return static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
   16615     }
   16616 
   16617 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16618     template <typename Allocator = std::allocator<uint8_t>>
   16619     typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache ) const
   16620     {
   16621       std::vector<uint8_t,Allocator> data;
   16622       size_t dataSize;
   16623       Result result;
   16624       do
   16625       {
   16626         result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
   16627         if ( ( result == Result::eSuccess ) && dataSize )
   16628         {
   16629           data.resize( dataSize );
   16630           result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
   16631         }
   16632       } while ( result == Result::eIncomplete );
   16633       assert( dataSize <= data.size() );
   16634       data.resize( dataSize );
   16635       return createResultValue( result, data, "vk::Device::getPipelineCacheData" );
   16636     }
   16637 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16638 
   16639     Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) const
   16640     {
   16641       return static_cast<Result>( vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
   16642     }
   16643 
   16644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16645     ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches ) const
   16646     {
   16647       Result result = static_cast<Result>( vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
   16648       return createResultValue( result, "vk::Device::mergePipelineCaches" );
   16649     }
   16650 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16651 
   16652     Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const
   16653     {
   16654       return static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
   16655     }
   16656 
   16657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16658     template <typename Allocator = std::allocator<Pipeline>>
   16659     typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16660     {
   16661       std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
   16662       Result result = static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
   16663       return createResultValue( result, pipelines, "vk::Device::createGraphicsPipelines" );
   16664     }
   16665 
   16666     ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16667     {
   16668       Pipeline pipeline;
   16669       Result result = static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
   16670       return createResultValue( result, pipeline, "vk::Device::createGraphicsPipeline" );
   16671     }
   16672 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16673 
   16674     Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const
   16675     {
   16676       return static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
   16677     }
   16678 
   16679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16680     template <typename Allocator = std::allocator<Pipeline>>
   16681     typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16682     {
   16683       std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
   16684       Result result = static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
   16685       return createResultValue( result, pipelines, "vk::Device::createComputePipelines" );
   16686     }
   16687 
   16688     ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16689     {
   16690       Pipeline pipeline;
   16691       Result result = static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
   16692       return createResultValue( result, pipeline, "vk::Device::createComputePipeline" );
   16693     }
   16694 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16695 
   16696     void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator ) const
   16697     {
   16698       vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16699     }
   16700 
   16701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16702     void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16703     {
   16704       vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16705     }
   16706 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16707 
   16708     Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout ) const
   16709     {
   16710       return static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
   16711     }
   16712 
   16713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16714     ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16715     {
   16716       PipelineLayout pipelineLayout;
   16717       Result result = static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
   16718       return createResultValue( result, pipelineLayout, "vk::Device::createPipelineLayout" );
   16719     }
   16720 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16721 
   16722     void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator ) const
   16723     {
   16724       vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16725     }
   16726 
   16727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16728     void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16729     {
   16730       vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16731     }
   16732 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16733 
   16734     Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler ) const
   16735     {
   16736       return static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
   16737     }
   16738 
   16739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16740     ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16741     {
   16742       Sampler sampler;
   16743       Result result = static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSampler*>( &sampler ) ) );
   16744       return createResultValue( result, sampler, "vk::Device::createSampler" );
   16745     }
   16746 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16747 
   16748     void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator ) const
   16749     {
   16750       vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16751     }
   16752 
   16753 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16754     void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16755     {
   16756       vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16757     }
   16758 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16759 
   16760     Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout ) const
   16761     {
   16762       return static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
   16763     }
   16764 
   16765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16766     ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16767     {
   16768       DescriptorSetLayout setLayout;
   16769       Result result = static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
   16770       return createResultValue( result, setLayout, "vk::Device::createDescriptorSetLayout" );
   16771     }
   16772 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16773 
   16774     void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator ) const
   16775     {
   16776       vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16777     }
   16778 
   16779 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16780     void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16781     {
   16782       vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16783     }
   16784 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16785 
   16786     Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool ) const
   16787     {
   16788       return static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
   16789     }
   16790 
   16791 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16792     ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16793     {
   16794       DescriptorPool descriptorPool;
   16795       Result result = static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
   16796       return createResultValue( result, descriptorPool, "vk::Device::createDescriptorPool" );
   16797     }
   16798 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16799 
   16800     void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator ) const
   16801     {
   16802       vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16803     }
   16804 
   16805 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16806     void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16807     {
   16808       vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16809     }
   16810 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16811 
   16812 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16813     Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const
   16814     {
   16815       return static_cast<Result>( vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
   16816     }
   16817 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16818 
   16819 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16820     ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags() ) const
   16821     {
   16822       Result result = static_cast<Result>( vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
   16823       return createResultValue( result, "vk::Device::resetDescriptorPool" );
   16824     }
   16825 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16826 
   16827     Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) const
   16828     {
   16829       return static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
   16830     }
   16831 
   16832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16833     template <typename Allocator = std::allocator<DescriptorSet>>
   16834     typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const
   16835     {
   16836       std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount );
   16837       Result result = static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
   16838       return createResultValue( result, descriptorSets, "vk::Device::allocateDescriptorSets" );
   16839     }
   16840 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16841 
   16842     Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets ) const
   16843     {
   16844       return static_cast<Result>( vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
   16845     }
   16846 
   16847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16848     ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets ) const
   16849     {
   16850       Result result = static_cast<Result>( vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
   16851       return createResultValue( result, "vk::Device::freeDescriptorSets" );
   16852     }
   16853 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16854 
   16855     void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies ) const
   16856     {
   16857       vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
   16858     }
   16859 
   16860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16861     void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies ) const
   16862     {
   16863       vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
   16864     }
   16865 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16866 
   16867     Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer ) const
   16868     {
   16869       return static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
   16870     }
   16871 
   16872 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16873     ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16874     {
   16875       Framebuffer framebuffer;
   16876       Result result = static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
   16877       return createResultValue( result, framebuffer, "vk::Device::createFramebuffer" );
   16878     }
   16879 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16880 
   16881     void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator ) const
   16882     {
   16883       vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16884     }
   16885 
   16886 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16887     void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16888     {
   16889       vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16890     }
   16891 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16892 
   16893     Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass ) const
   16894     {
   16895       return static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
   16896     }
   16897 
   16898 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16899     ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16900     {
   16901       RenderPass renderPass;
   16902       Result result = static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
   16903       return createResultValue( result, renderPass, "vk::Device::createRenderPass" );
   16904     }
   16905 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16906 
   16907     void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator ) const
   16908     {
   16909       vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16910     }
   16911 
   16912 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16913     void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16914     {
   16915       vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16916     }
   16917 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16918 
   16919     void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity ) const
   16920     {
   16921       vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
   16922     }
   16923 
   16924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16925     Extent2D getRenderAreaGranularity( RenderPass renderPass ) const
   16926     {
   16927       Extent2D granularity;
   16928       vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
   16929       return granularity;
   16930     }
   16931 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16932 
   16933     Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool ) const
   16934     {
   16935       return static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
   16936     }
   16937 
   16938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16939     ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16940     {
   16941       CommandPool commandPool;
   16942       Result result = static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
   16943       return createResultValue( result, commandPool, "vk::Device::createCommandPool" );
   16944     }
   16945 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16946 
   16947     void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator ) const
   16948     {
   16949       vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   16950     }
   16951 
   16952 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16953     void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr ) const
   16954     {
   16955       vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   16956     }
   16957 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16958 
   16959 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16960     Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const
   16961     {
   16962       return static_cast<Result>( vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
   16963     }
   16964 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16965 
   16966 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16967     ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const
   16968     {
   16969       Result result = static_cast<Result>( vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
   16970       return createResultValue( result, "vk::Device::resetCommandPool" );
   16971     }
   16972 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16973 
   16974     Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) const
   16975     {
   16976       return static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
   16977     }
   16978 
   16979 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16980     template <typename Allocator = std::allocator<CommandBuffer>>
   16981     typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const
   16982     {
   16983       std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount );
   16984       Result result = static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
   16985       return createResultValue( result, commandBuffers, "vk::Device::allocateCommandBuffers" );
   16986     }
   16987 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   16988 
   16989     void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const
   16990     {
   16991       vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
   16992     }
   16993 
   16994 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   16995     void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers ) const
   16996     {
   16997       vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
   16998     }
   16999 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17000 
   17001     Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) const
   17002     {
   17003       return static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
   17004     }
   17005 
   17006 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17007     template <typename Allocator = std::allocator<SwapchainKHR>>
   17008     typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const
   17009     {
   17010       std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
   17011       Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
   17012       return createResultValue( result, swapchains, "vk::Device::createSharedSwapchainsKHR" );
   17013     }
   17014 
   17015     ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   17016     {
   17017       SwapchainKHR swapchain;
   17018       Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
   17019       return createResultValue( result, swapchain, "vk::Device::createSharedSwapchainKHR" );
   17020     }
   17021 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17022 
   17023     Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain ) const
   17024     {
   17025       return static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
   17026     }
   17027 
   17028 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17029     ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   17030     {
   17031       SwapchainKHR swapchain;
   17032       Result result = static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
   17033       return createResultValue( result, swapchain, "vk::Device::createSwapchainKHR" );
   17034     }
   17035 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17036 
   17037     void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator ) const
   17038     {
   17039       vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   17040     }
   17041 
   17042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17043     void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr ) const
   17044     {
   17045       vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   17046     }
   17047 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17048 
   17049     Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) const
   17050     {
   17051       return static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
   17052     }
   17053 
   17054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17055     template <typename Allocator = std::allocator<Image>>
   17056     typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain ) const
   17057     {
   17058       std::vector<Image,Allocator> swapchainImages;
   17059       uint32_t swapchainImageCount;
   17060       Result result;
   17061       do
   17062       {
   17063         result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
   17064         if ( ( result == Result::eSuccess ) && swapchainImageCount )
   17065         {
   17066           swapchainImages.resize( swapchainImageCount );
   17067           result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
   17068         }
   17069       } while ( result == Result::eIncomplete );
   17070       assert( swapchainImageCount <= swapchainImages.size() );
   17071       swapchainImages.resize( swapchainImageCount );
   17072       return createResultValue( result, swapchainImages, "vk::Device::getSwapchainImagesKHR" );
   17073     }
   17074 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17075 
   17076     Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) const
   17077     {
   17078       return static_cast<Result>( vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
   17079     }
   17080 
   17081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17082     ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence ) const
   17083     {
   17084       uint32_t imageIndex;
   17085       Result result = static_cast<Result>( vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
   17086       return createResultValue( result, imageIndex, "vk::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
   17087     }
   17088 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17089 
   17090     Result debugMarkerSetObjectNameEXT( DebugMarkerObjectNameInfoEXT* pNameInfo ) const
   17091     {
   17092       return static_cast<Result>( vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
   17093     }
   17094 
   17095 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17096     ResultValueType<DebugMarkerObjectNameInfoEXT>::type debugMarkerSetObjectNameEXT() const
   17097     {
   17098       DebugMarkerObjectNameInfoEXT nameInfo;
   17099       Result result = static_cast<Result>( vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>( &nameInfo ) ) );
   17100       return createResultValue( result, nameInfo, "vk::Device::debugMarkerSetObjectNameEXT" );
   17101     }
   17102 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17103 
   17104     Result debugMarkerSetObjectTagEXT( DebugMarkerObjectTagInfoEXT* pTagInfo ) const
   17105     {
   17106       return static_cast<Result>( vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
   17107     }
   17108 
   17109 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17110     ResultValueType<DebugMarkerObjectTagInfoEXT>::type debugMarkerSetObjectTagEXT() const
   17111     {
   17112       DebugMarkerObjectTagInfoEXT tagInfo;
   17113       Result result = static_cast<Result>( vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>( &tagInfo ) ) );
   17114       return createResultValue( result, tagInfo, "vk::Device::debugMarkerSetObjectTagEXT" );
   17115     }
   17116 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17117 
   17118 #ifdef VK_USE_PLATFORM_WIN32_KHR
   17119     Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const
   17120     {
   17121       return static_cast<Result>( vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
   17122     }
   17123 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   17124 
   17125 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17126 #ifdef VK_USE_PLATFORM_WIN32_KHR
   17127     ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType ) const
   17128     {
   17129       HANDLE handle;
   17130       Result result = static_cast<Result>( vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
   17131       return createResultValue( result, handle, "vk::Device::getMemoryWin32HandleNV" );
   17132     }
   17133 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   17134 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17135 
   17136 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   17137     explicit
   17138 #endif
   17139     operator VkDevice() const
   17140     {
   17141       return m_device;
   17142     }
   17143 
   17144     explicit operator bool() const
   17145     {
   17146       return m_device != VK_NULL_HANDLE;
   17147     }
   17148 
   17149     bool operator!() const
   17150     {
   17151       return m_device == VK_NULL_HANDLE;
   17152     }
   17153 
   17154   private:
   17155     VkDevice m_device;
   17156   };
   17157   static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
   17158 
   17159   struct ExternalMemoryImageCreateInfoNV
   17160   {
   17161     ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
   17162       : sType( StructureType::eExternalMemoryImageCreateInfoNV )
   17163       , pNext( nullptr )
   17164       , handleTypes( handleTypes_ )
   17165     {
   17166     }
   17167 
   17168     ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
   17169     {
   17170       memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
   17171     }
   17172 
   17173     ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
   17174     {
   17175       memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
   17176       return *this;
   17177     }
   17178 
   17179     ExternalMemoryImageCreateInfoNV& setSType( StructureType sType_ )
   17180     {
   17181       sType = sType_;
   17182       return *this;
   17183     }
   17184 
   17185     ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
   17186     {
   17187       pNext = pNext_;
   17188       return *this;
   17189     }
   17190 
   17191     ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
   17192     {
   17193       handleTypes = handleTypes_;
   17194       return *this;
   17195     }
   17196 
   17197     operator const VkExternalMemoryImageCreateInfoNV&() const
   17198     {
   17199       return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
   17200     }
   17201 
   17202     bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
   17203     {
   17204       return ( sType == rhs.sType )
   17205           && ( pNext == rhs.pNext )
   17206           && ( handleTypes == rhs.handleTypes );
   17207     }
   17208 
   17209     bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
   17210     {
   17211       return !operator==( rhs );
   17212     }
   17213 
   17214   private:
   17215     StructureType sType;
   17216 
   17217   public:
   17218     const void* pNext;
   17219     ExternalMemoryHandleTypeFlagsNV handleTypes;
   17220   };
   17221   static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
   17222 
   17223   struct ExportMemoryAllocateInfoNV
   17224   {
   17225     ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
   17226       : sType( StructureType::eExportMemoryAllocateInfoNV )
   17227       , pNext( nullptr )
   17228       , handleTypes( handleTypes_ )
   17229     {
   17230     }
   17231 
   17232     ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
   17233     {
   17234       memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
   17235     }
   17236 
   17237     ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
   17238     {
   17239       memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
   17240       return *this;
   17241     }
   17242 
   17243     ExportMemoryAllocateInfoNV& setSType( StructureType sType_ )
   17244     {
   17245       sType = sType_;
   17246       return *this;
   17247     }
   17248 
   17249     ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
   17250     {
   17251       pNext = pNext_;
   17252       return *this;
   17253     }
   17254 
   17255     ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
   17256     {
   17257       handleTypes = handleTypes_;
   17258       return *this;
   17259     }
   17260 
   17261     operator const VkExportMemoryAllocateInfoNV&() const
   17262     {
   17263       return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
   17264     }
   17265 
   17266     bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
   17267     {
   17268       return ( sType == rhs.sType )
   17269           && ( pNext == rhs.pNext )
   17270           && ( handleTypes == rhs.handleTypes );
   17271     }
   17272 
   17273     bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
   17274     {
   17275       return !operator==( rhs );
   17276     }
   17277 
   17278   private:
   17279     StructureType sType;
   17280 
   17281   public:
   17282     const void* pNext;
   17283     ExternalMemoryHandleTypeFlagsNV handleTypes;
   17284   };
   17285   static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   17286 
   17287 #ifdef VK_USE_PLATFORM_WIN32_KHR
   17288   struct ImportMemoryWin32HandleInfoNV
   17289   {
   17290     ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
   17291       : sType( StructureType::eImportMemoryWin32HandleInfoNV )
   17292       , pNext( nullptr )
   17293       , handleType( handleType_ )
   17294       , handle( handle_ )
   17295     {
   17296     }
   17297 
   17298     ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
   17299     {
   17300       memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
   17301     }
   17302 
   17303     ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
   17304     {
   17305       memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
   17306       return *this;
   17307     }
   17308 
   17309     ImportMemoryWin32HandleInfoNV& setSType( StructureType sType_ )
   17310     {
   17311       sType = sType_;
   17312       return *this;
   17313     }
   17314 
   17315     ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
   17316     {
   17317       pNext = pNext_;
   17318       return *this;
   17319     }
   17320 
   17321     ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
   17322     {
   17323       handleType = handleType_;
   17324       return *this;
   17325     }
   17326 
   17327     ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
   17328     {
   17329       handle = handle_;
   17330       return *this;
   17331     }
   17332 
   17333     operator const VkImportMemoryWin32HandleInfoNV&() const
   17334     {
   17335       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
   17336     }
   17337 
   17338     bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
   17339     {
   17340       return ( sType == rhs.sType )
   17341           && ( pNext == rhs.pNext )
   17342           && ( handleType == rhs.handleType )
   17343           && ( handle == rhs.handle );
   17344     }
   17345 
   17346     bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
   17347     {
   17348       return !operator==( rhs );
   17349     }
   17350 
   17351   private:
   17352     StructureType sType;
   17353 
   17354   public:
   17355     const void* pNext;
   17356     ExternalMemoryHandleTypeFlagsNV handleType;
   17357     HANDLE handle;
   17358   };
   17359   static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   17360 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   17361 
   17362   enum class ExternalMemoryFeatureFlagBitsNV
   17363   {
   17364     eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
   17365     eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
   17366     eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
   17367   };
   17368 
   17369   using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
   17370 
   17371   inline ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
   17372   {
   17373     return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
   17374   }
   17375 
   17376   struct ExternalImageFormatPropertiesNV
   17377   {
   17378     ExternalImageFormatPropertiesNV( ImageFormatProperties imageFormatProperties_ = ImageFormatProperties(), ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = ExternalMemoryFeatureFlagsNV(), ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = ExternalMemoryHandleTypeFlagsNV(), ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
   17379       : imageFormatProperties( imageFormatProperties_ )
   17380       , externalMemoryFeatures( externalMemoryFeatures_ )
   17381       , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
   17382       , compatibleHandleTypes( compatibleHandleTypes_ )
   17383     {
   17384     }
   17385 
   17386     ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs )
   17387     {
   17388       memcpy( this, &rhs, sizeof(ExternalImageFormatPropertiesNV) );
   17389     }
   17390 
   17391     ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs )
   17392     {
   17393       memcpy( this, &rhs, sizeof(ExternalImageFormatPropertiesNV) );
   17394       return *this;
   17395     }
   17396 
   17397     ExternalImageFormatPropertiesNV& setImageFormatProperties( ImageFormatProperties imageFormatProperties_ )
   17398     {
   17399       imageFormatProperties = imageFormatProperties_;
   17400       return *this;
   17401     }
   17402 
   17403     ExternalImageFormatPropertiesNV& setExternalMemoryFeatures( ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ )
   17404     {
   17405       externalMemoryFeatures = externalMemoryFeatures_;
   17406       return *this;
   17407     }
   17408 
   17409     ExternalImageFormatPropertiesNV& setExportFromImportedHandleTypes( ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ )
   17410     {
   17411       exportFromImportedHandleTypes = exportFromImportedHandleTypes_;
   17412       return *this;
   17413     }
   17414 
   17415     ExternalImageFormatPropertiesNV& setCompatibleHandleTypes( ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ )
   17416     {
   17417       compatibleHandleTypes = compatibleHandleTypes_;
   17418       return *this;
   17419     }
   17420 
   17421     operator const VkExternalImageFormatPropertiesNV&() const
   17422     {
   17423       return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
   17424     }
   17425 
   17426     bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
   17427     {
   17428       return ( imageFormatProperties == rhs.imageFormatProperties )
   17429           && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
   17430           && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
   17431           && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
   17432     }
   17433 
   17434     bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
   17435     {
   17436       return !operator==( rhs );
   17437     }
   17438 
   17439     ImageFormatProperties imageFormatProperties;
   17440     ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
   17441     ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
   17442     ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
   17443   };
   17444   static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
   17445 
   17446   struct ExternalMemoryImageCreateInfoNV
   17447   {
   17448     ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
   17449       : sType( StructureType::eExternalMemoryImageCreateInfoNV )
   17450       , pNext( nullptr )
   17451       , handleTypes( handleTypes_ )
   17452     {
   17453     }
   17454 
   17455     ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
   17456     {
   17457       memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
   17458     }
   17459 
   17460     ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
   17461     {
   17462       memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
   17463       return *this;
   17464     }
   17465 
   17466     ExternalMemoryImageCreateInfoNV& setSType( StructureType sType_ )
   17467     {
   17468       sType = sType_;
   17469       return *this;
   17470     }
   17471 
   17472     ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
   17473     {
   17474       pNext = pNext_;
   17475       return *this;
   17476     }
   17477 
   17478     ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
   17479     {
   17480       handleTypes = handleTypes_;
   17481       return *this;
   17482     }
   17483 
   17484     operator const VkExternalMemoryImageCreateInfoNV&() const
   17485     {
   17486       return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
   17487     }
   17488 
   17489     bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
   17490     {
   17491       return ( sType == rhs.sType )
   17492           && ( pNext == rhs.pNext )
   17493           && ( handleTypes == rhs.handleTypes );
   17494     }
   17495 
   17496     bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
   17497     {
   17498       return !operator==( rhs );
   17499     }
   17500 
   17501   private:
   17502     StructureType sType;
   17503 
   17504   public:
   17505     const void* pNext;
   17506     ExternalMemoryHandleTypeFlagsNV handleTypes;
   17507   };
   17508   static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
   17509 
   17510   struct ExportMemoryAllocateInfoNV
   17511   {
   17512     ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
   17513       : sType( StructureType::eExportMemoryAllocateInfoNV )
   17514       , pNext( nullptr )
   17515       , handleTypes( handleTypes_ )
   17516     {
   17517     }
   17518 
   17519     ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
   17520     {
   17521       memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
   17522     }
   17523 
   17524     ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
   17525     {
   17526       memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
   17527       return *this;
   17528     }
   17529 
   17530     ExportMemoryAllocateInfoNV& setSType( StructureType sType_ )
   17531     {
   17532       sType = sType_;
   17533       return *this;
   17534     }
   17535 
   17536     ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
   17537     {
   17538       pNext = pNext_;
   17539       return *this;
   17540     }
   17541 
   17542     ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
   17543     {
   17544       handleTypes = handleTypes_;
   17545       return *this;
   17546     }
   17547 
   17548     operator const VkExportMemoryAllocateInfoNV&() const
   17549     {
   17550       return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
   17551     }
   17552 
   17553     bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
   17554     {
   17555       return ( sType == rhs.sType )
   17556           && ( pNext == rhs.pNext )
   17557           && ( handleTypes == rhs.handleTypes );
   17558     }
   17559 
   17560     bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
   17561     {
   17562       return !operator==( rhs );
   17563     }
   17564 
   17565   private:
   17566     StructureType sType;
   17567 
   17568   public:
   17569     const void* pNext;
   17570     ExternalMemoryHandleTypeFlagsNV handleTypes;
   17571   };
   17572   static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
   17573 
   17574 #ifdef VK_USE_PLATFORM_WIN32_KHR
   17575   struct ImportMemoryWin32HandleInfoNV
   17576   {
   17577     ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
   17578       : sType( StructureType::eImportMemoryWin32HandleInfoNV )
   17579       , pNext( nullptr )
   17580       , handleType( handleType_ )
   17581       , handle( handle_ )
   17582     {
   17583     }
   17584 
   17585     ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
   17586     {
   17587       memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
   17588     }
   17589 
   17590     ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
   17591     {
   17592       memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
   17593       return *this;
   17594     }
   17595 
   17596     ImportMemoryWin32HandleInfoNV& setSType( StructureType sType_ )
   17597     {
   17598       sType = sType_;
   17599       return *this;
   17600     }
   17601 
   17602     ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
   17603     {
   17604       pNext = pNext_;
   17605       return *this;
   17606     }
   17607 
   17608     ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
   17609     {
   17610       handleType = handleType_;
   17611       return *this;
   17612     }
   17613 
   17614     ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
   17615     {
   17616       handle = handle_;
   17617       return *this;
   17618     }
   17619 
   17620     operator const VkImportMemoryWin32HandleInfoNV&() const
   17621     {
   17622       return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
   17623     }
   17624 
   17625     bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
   17626     {
   17627       return ( sType == rhs.sType )
   17628           && ( pNext == rhs.pNext )
   17629           && ( handleType == rhs.handleType )
   17630           && ( handle == rhs.handle );
   17631     }
   17632 
   17633     bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
   17634     {
   17635       return !operator==( rhs );
   17636     }
   17637 
   17638   private:
   17639     StructureType sType;
   17640 
   17641   public:
   17642     const void* pNext;
   17643     ExternalMemoryHandleTypeFlagsNV handleType;
   17644     HANDLE handle;
   17645   };
   17646   static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
   17647 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   17648 
   17649   enum class ExternalMemoryFeatureFlagBitsNV
   17650   {
   17651     eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
   17652     eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
   17653     eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
   17654   };
   17655 
   17656   using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
   17657 
   17658   inline ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
   17659   {
   17660     return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
   17661   }
   17662 
   17663   struct ExternalImageFormatPropertiesNV
   17664   {
   17665     ExternalImageFormatPropertiesNV( ImageFormatProperties imageFormatProperties_ = ImageFormatProperties(), ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = ExternalMemoryFeatureFlagsNV(), ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = ExternalMemoryHandleTypeFlagsNV(), ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
   17666       : imageFormatProperties( imageFormatProperties_ )
   17667       , externalMemoryFeatures( externalMemoryFeatures_ )
   17668       , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ )
   17669       , compatibleHandleTypes( compatibleHandleTypes_ )
   17670     {
   17671     }
   17672 
   17673     ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs )
   17674     {
   17675       memcpy( this, &rhs, sizeof(ExternalImageFormatPropertiesNV) );
   17676     }
   17677 
   17678     ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs )
   17679     {
   17680       memcpy( this, &rhs, sizeof(ExternalImageFormatPropertiesNV) );
   17681       return *this;
   17682     }
   17683 
   17684     ExternalImageFormatPropertiesNV& setImageFormatProperties( ImageFormatProperties imageFormatProperties_ )
   17685     {
   17686       imageFormatProperties = imageFormatProperties_;
   17687       return *this;
   17688     }
   17689 
   17690     ExternalImageFormatPropertiesNV& setExternalMemoryFeatures( ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ )
   17691     {
   17692       externalMemoryFeatures = externalMemoryFeatures_;
   17693       return *this;
   17694     }
   17695 
   17696     ExternalImageFormatPropertiesNV& setExportFromImportedHandleTypes( ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ )
   17697     {
   17698       exportFromImportedHandleTypes = exportFromImportedHandleTypes_;
   17699       return *this;
   17700     }
   17701 
   17702     ExternalImageFormatPropertiesNV& setCompatibleHandleTypes( ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ )
   17703     {
   17704       compatibleHandleTypes = compatibleHandleTypes_;
   17705       return *this;
   17706     }
   17707 
   17708     operator const VkExternalImageFormatPropertiesNV&() const
   17709     {
   17710       return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
   17711     }
   17712 
   17713     bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
   17714     {
   17715       return ( imageFormatProperties == rhs.imageFormatProperties )
   17716           && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
   17717           && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
   17718           && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
   17719     }
   17720 
   17721     bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
   17722     {
   17723       return !operator==( rhs );
   17724     }
   17725 
   17726     ImageFormatProperties imageFormatProperties;
   17727     ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
   17728     ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
   17729     ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
   17730   };
   17731   static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
   17732 
   17733   class PhysicalDevice
   17734   {
   17735   public:
   17736     PhysicalDevice()
   17737       : m_physicalDevice(VK_NULL_HANDLE)
   17738     {}
   17739 
   17740 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   17741     PhysicalDevice(VkPhysicalDevice physicalDevice)
   17742        : m_physicalDevice(physicalDevice)
   17743     {}
   17744 
   17745     PhysicalDevice& operator=(VkPhysicalDevice physicalDevice)
   17746     {
   17747       m_physicalDevice = physicalDevice;
   17748       return *this;
   17749     }
   17750 #endif
   17751 
   17752     bool operator==(PhysicalDevice const &rhs) const
   17753     {
   17754       return m_physicalDevice == rhs.m_physicalDevice;
   17755     }
   17756 
   17757     bool operator!=(PhysicalDevice const &rhs) const
   17758     {
   17759       return m_physicalDevice != rhs.m_physicalDevice;
   17760     }
   17761 
   17762     bool operator<(PhysicalDevice const &rhs) const
   17763     {
   17764       return m_physicalDevice < rhs.m_physicalDevice;
   17765     }
   17766 
   17767     void getProperties( PhysicalDeviceProperties* pProperties ) const
   17768     {
   17769       vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
   17770     }
   17771 
   17772 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17773     PhysicalDeviceProperties getProperties() const
   17774     {
   17775       PhysicalDeviceProperties properties;
   17776       vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
   17777       return properties;
   17778     }
   17779 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17780 
   17781     void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) const
   17782     {
   17783       vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
   17784     }
   17785 
   17786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17787     template <typename Allocator = std::allocator<QueueFamilyProperties>>
   17788     std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties() const
   17789     {
   17790       std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties;
   17791       uint32_t queueFamilyPropertyCount;
   17792       vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
   17793       queueFamilyProperties.resize( queueFamilyPropertyCount );
   17794       vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
   17795       return queueFamilyProperties;
   17796     }
   17797 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17798 
   17799     void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties ) const
   17800     {
   17801       vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
   17802     }
   17803 
   17804 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17805     PhysicalDeviceMemoryProperties getMemoryProperties() const
   17806     {
   17807       PhysicalDeviceMemoryProperties memoryProperties;
   17808       vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
   17809       return memoryProperties;
   17810     }
   17811 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17812 
   17813     void getFeatures( PhysicalDeviceFeatures* pFeatures ) const
   17814     {
   17815       vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
   17816     }
   17817 
   17818 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17819     PhysicalDeviceFeatures getFeatures() const
   17820     {
   17821       PhysicalDeviceFeatures features;
   17822       vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
   17823       return features;
   17824     }
   17825 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17826 
   17827     void getFormatProperties( Format format, FormatProperties* pFormatProperties ) const
   17828     {
   17829       vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
   17830     }
   17831 
   17832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17833     FormatProperties getFormatProperties( Format format ) const
   17834     {
   17835       FormatProperties formatProperties;
   17836       vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
   17837       return formatProperties;
   17838     }
   17839 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17840 
   17841     Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties ) const
   17842     {
   17843       return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( pImageFormatProperties ) ) );
   17844     }
   17845 
   17846 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17847     ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const
   17848     {
   17849       ImageFormatProperties imageFormatProperties;
   17850       Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( &imageFormatProperties ) ) );
   17851       return createResultValue( result, imageFormatProperties, "vk::PhysicalDevice::getImageFormatProperties" );
   17852     }
   17853 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17854 
   17855     Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice ) const
   17856     {
   17857       return static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
   17858     }
   17859 
   17860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17861     ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   17862     {
   17863       Device device;
   17864       Result result = static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDevice*>( &device ) ) );
   17865       return createResultValue( result, device, "vk::PhysicalDevice::createDevice" );
   17866     }
   17867 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17868 
   17869     Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) const
   17870     {
   17871       return static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
   17872     }
   17873 
   17874 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17875     template <typename Allocator = std::allocator<LayerProperties>>
   17876     typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties() const
   17877     {
   17878       std::vector<LayerProperties,Allocator> properties;
   17879       uint32_t propertyCount;
   17880       Result result;
   17881       do
   17882       {
   17883         result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
   17884         if ( ( result == Result::eSuccess ) && propertyCount )
   17885         {
   17886           properties.resize( propertyCount );
   17887           result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
   17888         }
   17889       } while ( result == Result::eIncomplete );
   17890       assert( propertyCount <= properties.size() );
   17891       properties.resize( propertyCount );
   17892       return createResultValue( result, properties, "vk::PhysicalDevice::enumerateDeviceLayerProperties" );
   17893     }
   17894 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17895 
   17896     Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) const
   17897     {
   17898       return static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
   17899     }
   17900 
   17901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17902     template <typename Allocator = std::allocator<ExtensionProperties>>
   17903     typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr ) const
   17904     {
   17905       std::vector<ExtensionProperties,Allocator> properties;
   17906       uint32_t propertyCount;
   17907       Result result;
   17908       do
   17909       {
   17910         result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
   17911         if ( ( result == Result::eSuccess ) && propertyCount )
   17912         {
   17913           properties.resize( propertyCount );
   17914           result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
   17915         }
   17916       } while ( result == Result::eIncomplete );
   17917       assert( propertyCount <= properties.size() );
   17918       properties.resize( propertyCount );
   17919       return createResultValue( result, properties, "vk::PhysicalDevice::enumerateDeviceExtensionProperties" );
   17920     }
   17921 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17922 
   17923     void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) const
   17924     {
   17925       vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( pProperties ) );
   17926     }
   17927 
   17928 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17929     template <typename Allocator = std::allocator<SparseImageFormatProperties>>
   17930     std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const
   17931     {
   17932       std::vector<SparseImageFormatProperties,Allocator> properties;
   17933       uint32_t propertyCount;
   17934       vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
   17935       properties.resize( propertyCount );
   17936       vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
   17937       return properties;
   17938     }
   17939 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17940 
   17941     Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) const
   17942     {
   17943       return static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
   17944     }
   17945 
   17946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17947     template <typename Allocator = std::allocator<DisplayPropertiesKHR>>
   17948     typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR() const
   17949     {
   17950       std::vector<DisplayPropertiesKHR,Allocator> properties;
   17951       uint32_t propertyCount;
   17952       Result result;
   17953       do
   17954       {
   17955         result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
   17956         if ( ( result == Result::eSuccess ) && propertyCount )
   17957         {
   17958           properties.resize( propertyCount );
   17959           result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
   17960         }
   17961       } while ( result == Result::eIncomplete );
   17962       assert( propertyCount <= properties.size() );
   17963       properties.resize( propertyCount );
   17964       return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayPropertiesKHR" );
   17965     }
   17966 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17967 
   17968     Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) const
   17969     {
   17970       return static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
   17971     }
   17972 
   17973 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   17974     template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>>
   17975     typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR() const
   17976     {
   17977       std::vector<DisplayPlanePropertiesKHR,Allocator> properties;
   17978       uint32_t propertyCount;
   17979       Result result;
   17980       do
   17981       {
   17982         result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
   17983         if ( ( result == Result::eSuccess ) && propertyCount )
   17984         {
   17985           properties.resize( propertyCount );
   17986           result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
   17987         }
   17988       } while ( result == Result::eIncomplete );
   17989       assert( propertyCount <= properties.size() );
   17990       properties.resize( propertyCount );
   17991       return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayPlanePropertiesKHR" );
   17992     }
   17993 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   17994 
   17995     Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) const
   17996     {
   17997       return static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
   17998     }
   17999 
   18000 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18001     template <typename Allocator = std::allocator<DisplayKHR>>
   18002     typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const
   18003     {
   18004       std::vector<DisplayKHR,Allocator> displays;
   18005       uint32_t displayCount;
   18006       Result result;
   18007       do
   18008       {
   18009         result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
   18010         if ( ( result == Result::eSuccess ) && displayCount )
   18011         {
   18012           displays.resize( displayCount );
   18013           result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
   18014         }
   18015       } while ( result == Result::eIncomplete );
   18016       assert( displayCount <= displays.size() );
   18017       displays.resize( displayCount );
   18018       return createResultValue( result, displays, "vk::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
   18019     }
   18020 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18021 
   18022     Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) const
   18023     {
   18024       return static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
   18025     }
   18026 
   18027 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18028     template <typename Allocator = std::allocator<DisplayModePropertiesKHR>>
   18029     typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display ) const
   18030     {
   18031       std::vector<DisplayModePropertiesKHR,Allocator> properties;
   18032       uint32_t propertyCount;
   18033       Result result;
   18034       do
   18035       {
   18036         result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
   18037         if ( ( result == Result::eSuccess ) && propertyCount )
   18038         {
   18039           properties.resize( propertyCount );
   18040           result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
   18041         }
   18042       } while ( result == Result::eIncomplete );
   18043       assert( propertyCount <= properties.size() );
   18044       properties.resize( propertyCount );
   18045       return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayModePropertiesKHR" );
   18046     }
   18047 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18048 
   18049     Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) const
   18050     {
   18051       return static_cast<Result>( vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
   18052     }
   18053 
   18054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18055     ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18056     {
   18057       DisplayModeKHR mode;
   18058       Result result = static_cast<Result>( vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDisplayModeKHR*>( &mode ) ) );
   18059       return createResultValue( result, mode, "vk::PhysicalDevice::createDisplayModeKHR" );
   18060     }
   18061 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18062 
   18063     Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities ) const
   18064     {
   18065       return static_cast<Result>( vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
   18066     }
   18067 
   18068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18069     ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex ) const
   18070     {
   18071       DisplayPlaneCapabilitiesKHR capabilities;
   18072       Result result = static_cast<Result>( vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
   18073       return createResultValue( result, capabilities, "vk::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
   18074     }
   18075 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18076 
   18077 #ifdef VK_USE_PLATFORM_MIR_KHR
   18078     Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection ) const
   18079     {
   18080       return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection );
   18081     }
   18082 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   18083 
   18084 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18085 #ifdef VK_USE_PLATFORM_MIR_KHR
   18086     Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection ) const
   18087     {
   18088       return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection );
   18089     }
   18090 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   18091 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18092 
   18093     Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const
   18094     {
   18095       return static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) );
   18096     }
   18097 
   18098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18099     ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const
   18100     {
   18101       Bool32 supported;
   18102       Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) );
   18103       return createResultValue( result, supported, "vk::PhysicalDevice::getSurfaceSupportKHR" );
   18104     }
   18105 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18106 
   18107     Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
   18108     {
   18109       return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
   18110     }
   18111 
   18112 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18113     ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const
   18114     {
   18115       SurfaceCapabilitiesKHR surfaceCapabilities;
   18116       Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
   18117       return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilitiesKHR" );
   18118     }
   18119 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18120 
   18121     Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const
   18122     {
   18123       return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
   18124     }
   18125 
   18126 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18127     template <typename Allocator = std::allocator<SurfaceFormatKHR>>
   18128     typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface ) const
   18129     {
   18130       std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
   18131       uint32_t surfaceFormatCount;
   18132       Result result;
   18133       do
   18134       {
   18135         result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
   18136         if ( ( result == Result::eSuccess ) && surfaceFormatCount )
   18137         {
   18138           surfaceFormats.resize( surfaceFormatCount );
   18139           result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
   18140         }
   18141       } while ( result == Result::eIncomplete );
   18142       assert( surfaceFormatCount <= surfaceFormats.size() );
   18143       surfaceFormats.resize( surfaceFormatCount );
   18144       return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormatsKHR" );
   18145     }
   18146 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18147 
   18148     Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const
   18149     {
   18150       return static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
   18151     }
   18152 
   18153 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18154     template <typename Allocator = std::allocator<PresentModeKHR>>
   18155     typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface ) const
   18156     {
   18157       std::vector<PresentModeKHR,Allocator> presentModes;
   18158       uint32_t presentModeCount;
   18159       Result result;
   18160       do
   18161       {
   18162         result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
   18163         if ( ( result == Result::eSuccess ) && presentModeCount )
   18164         {
   18165           presentModes.resize( presentModeCount );
   18166           result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
   18167         }
   18168       } while ( result == Result::eIncomplete );
   18169       assert( presentModeCount <= presentModes.size() );
   18170       presentModes.resize( presentModeCount );
   18171       return createResultValue( result, presentModes, "vk::PhysicalDevice::getSurfacePresentModesKHR" );
   18172     }
   18173 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18174 
   18175 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   18176     Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const
   18177     {
   18178       return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display );
   18179     }
   18180 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   18181 
   18182 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18183 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   18184     Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const
   18185     {
   18186       return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
   18187     }
   18188 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   18189 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18190 
   18191 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18192 #ifdef VK_USE_PLATFORM_WIN32_KHR
   18193     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const
   18194     {
   18195       return vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
   18196     }
   18197 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   18198 #endif /*!VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18199 
   18200 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18201 #ifdef VK_USE_PLATFORM_WIN32_KHR
   18202     Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const
   18203     {
   18204       return vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
   18205     }
   18206 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   18207 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18208 
   18209 #ifdef VK_USE_PLATFORM_XLIB_KHR
   18210     Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
   18211     {
   18212       return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID );
   18213     }
   18214 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   18215 
   18216 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18217 #ifdef VK_USE_PLATFORM_XLIB_KHR
   18218     Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const
   18219     {
   18220       return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
   18221     }
   18222 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   18223 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18224 
   18225 #ifdef VK_USE_PLATFORM_XCB_KHR
   18226     Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
   18227     {
   18228       return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id );
   18229     }
   18230 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   18231 
   18232 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18233 #ifdef VK_USE_PLATFORM_XCB_KHR
   18234     Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const
   18235     {
   18236       return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
   18237     }
   18238 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   18239 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18240 
   18241     Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const
   18242     {
   18243       return static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
   18244     }
   18245 
   18246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18247     ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const
   18248     {
   18249       ExternalImageFormatPropertiesNV externalImageFormatProperties;
   18250       Result result = static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
   18251       return createResultValue( result, externalImageFormatProperties, "vk::PhysicalDevice::getExternalImageFormatPropertiesNV" );
   18252     }
   18253 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18254 
   18255 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   18256     explicit
   18257 #endif
   18258     operator VkPhysicalDevice() const
   18259     {
   18260       return m_physicalDevice;
   18261     }
   18262 
   18263     explicit operator bool() const
   18264     {
   18265       return m_physicalDevice != VK_NULL_HANDLE;
   18266     }
   18267 
   18268     bool operator!() const
   18269     {
   18270       return m_physicalDevice == VK_NULL_HANDLE;
   18271     }
   18272 
   18273   private:
   18274     VkPhysicalDevice m_physicalDevice;
   18275   };
   18276   static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
   18277 
   18278   class Instance
   18279   {
   18280   public:
   18281     Instance()
   18282       : m_instance(VK_NULL_HANDLE)
   18283     {}
   18284 
   18285 #if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   18286     Instance(VkInstance instance)
   18287        : m_instance(instance)
   18288     {}
   18289 
   18290     Instance& operator=(VkInstance instance)
   18291     {
   18292       m_instance = instance;
   18293       return *this;
   18294     }
   18295 #endif
   18296 
   18297     bool operator==(Instance const &rhs) const
   18298     {
   18299       return m_instance == rhs.m_instance;
   18300     }
   18301 
   18302     bool operator!=(Instance const &rhs) const
   18303     {
   18304       return m_instance != rhs.m_instance;
   18305     }
   18306 
   18307     bool operator<(Instance const &rhs) const
   18308     {
   18309       return m_instance < rhs.m_instance;
   18310     }
   18311 
   18312     void destroy( const AllocationCallbacks* pAllocator ) const
   18313     {
   18314       vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   18315     }
   18316 
   18317 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18318     void destroy( Optional<const AllocationCallbacks> allocator = nullptr ) const
   18319     {
   18320       vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   18321     }
   18322 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18323 
   18324     Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) const
   18325     {
   18326       return static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
   18327     }
   18328 
   18329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18330     template <typename Allocator = std::allocator<PhysicalDevice>>
   18331     typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices() const
   18332     {
   18333       std::vector<PhysicalDevice,Allocator> physicalDevices;
   18334       uint32_t physicalDeviceCount;
   18335       Result result;
   18336       do
   18337       {
   18338         result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
   18339         if ( ( result == Result::eSuccess ) && physicalDeviceCount )
   18340         {
   18341           physicalDevices.resize( physicalDeviceCount );
   18342           result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
   18343         }
   18344       } while ( result == Result::eIncomplete );
   18345       assert( physicalDeviceCount <= physicalDevices.size() );
   18346       physicalDevices.resize( physicalDeviceCount );
   18347       return createResultValue( result, physicalDevices, "vk::Instance::enumeratePhysicalDevices" );
   18348     }
   18349 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18350 
   18351     PFN_vkVoidFunction getProcAddr( const char* pName ) const
   18352     {
   18353       return vkGetInstanceProcAddr( m_instance, pName );
   18354     }
   18355 
   18356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18357     PFN_vkVoidFunction getProcAddr( const std::string & name ) const
   18358     {
   18359       return vkGetInstanceProcAddr( m_instance, name.c_str() );
   18360     }
   18361 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18362 
   18363 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   18364     Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18365     {
   18366       return static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18367     }
   18368 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
   18369 
   18370 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18371 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   18372     ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18373     {
   18374       SurfaceKHR surface;
   18375       Result result = static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18376       return createResultValue( result, surface, "vk::Instance::createAndroidSurfaceKHR" );
   18377     }
   18378 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
   18379 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18380 
   18381     Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18382     {
   18383       return static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18384     }
   18385 
   18386 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18387     ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18388     {
   18389       SurfaceKHR surface;
   18390       Result result = static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18391       return createResultValue( result, surface, "vk::Instance::createDisplayPlaneSurfaceKHR" );
   18392     }
   18393 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18394 
   18395 #ifdef VK_USE_PLATFORM_MIR_KHR
   18396     Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18397     {
   18398       return static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18399     }
   18400 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   18401 
   18402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18403 #ifdef VK_USE_PLATFORM_MIR_KHR
   18404     ResultValueType<SurfaceKHR>::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18405     {
   18406       SurfaceKHR surface;
   18407       Result result = static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18408       return createResultValue( result, surface, "vk::Instance::createMirSurfaceKHR" );
   18409     }
   18410 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   18411 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18412 
   18413     void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator ) const
   18414     {
   18415       vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   18416     }
   18417 
   18418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18419     void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18420     {
   18421       vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   18422     }
   18423 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18424 
   18425 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   18426     Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18427     {
   18428       return static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18429     }
   18430 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   18431 
   18432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18433 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   18434     ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18435     {
   18436       SurfaceKHR surface;
   18437       Result result = static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18438       return createResultValue( result, surface, "vk::Instance::createWaylandSurfaceKHR" );
   18439     }
   18440 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   18441 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18442 
   18443 #ifdef VK_USE_PLATFORM_WIN32_KHR
   18444     Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18445     {
   18446       return static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18447     }
   18448 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   18449 
   18450 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18451 #ifdef VK_USE_PLATFORM_WIN32_KHR
   18452     ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18453     {
   18454       SurfaceKHR surface;
   18455       Result result = static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18456       return createResultValue( result, surface, "vk::Instance::createWin32SurfaceKHR" );
   18457     }
   18458 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   18459 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18460 
   18461 #ifdef VK_USE_PLATFORM_XLIB_KHR
   18462     Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18463     {
   18464       return static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18465     }
   18466 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   18467 
   18468 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18469 #ifdef VK_USE_PLATFORM_XLIB_KHR
   18470     ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18471     {
   18472       SurfaceKHR surface;
   18473       Result result = static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18474       return createResultValue( result, surface, "vk::Instance::createXlibSurfaceKHR" );
   18475     }
   18476 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   18477 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18478 
   18479 #ifdef VK_USE_PLATFORM_XCB_KHR
   18480     Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
   18481     {
   18482       return static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
   18483     }
   18484 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   18485 
   18486 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18487 #ifdef VK_USE_PLATFORM_XCB_KHR
   18488     ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18489     {
   18490       SurfaceKHR surface;
   18491       Result result = static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
   18492       return createResultValue( result, surface, "vk::Instance::createXcbSurfaceKHR" );
   18493     }
   18494 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   18495 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18496 
   18497     Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback ) const
   18498     {
   18499       return static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
   18500     }
   18501 
   18502 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18503     ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18504     {
   18505       DebugReportCallbackEXT callback;
   18506       Result result = static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
   18507       return createResultValue( result, callback, "vk::Instance::createDebugReportCallbackEXT" );
   18508     }
   18509 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18510 
   18511     void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator ) const
   18512     {
   18513       vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
   18514     }
   18515 
   18516 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18517     void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr ) const
   18518     {
   18519       vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)) );
   18520     }
   18521 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18522 
   18523     void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const
   18524     {
   18525       vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
   18526     }
   18527 
   18528 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18529     void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message ) const
   18530     {
   18531       vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
   18532     }
   18533 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18534 
   18535 #if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
   18536     explicit
   18537 #endif
   18538     operator VkInstance() const
   18539     {
   18540       return m_instance;
   18541     }
   18542 
   18543     explicit operator bool() const
   18544     {
   18545       return m_instance != VK_NULL_HANDLE;
   18546     }
   18547 
   18548     bool operator!() const
   18549     {
   18550       return m_instance == VK_NULL_HANDLE;
   18551     }
   18552 
   18553   private:
   18554     VkInstance m_instance;
   18555   };
   18556   static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
   18557 
   18558   enum class ValidationCheckEXT
   18559   {
   18560     eAll = VK_VALIDATION_CHECK_ALL_EXT
   18561   };
   18562 
   18563   struct ValidationFlagsEXT
   18564   {
   18565     ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
   18566       : sType( StructureType::eValidationFlagsEXT )
   18567       , pNext( nullptr )
   18568       , disabledValidationCheckCount( disabledValidationCheckCount_ )
   18569       , pDisabledValidationChecks( pDisabledValidationChecks_ )
   18570     {
   18571     }
   18572 
   18573     ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
   18574     {
   18575       memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
   18576     }
   18577 
   18578     ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
   18579     {
   18580       memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
   18581       return *this;
   18582     }
   18583 
   18584     ValidationFlagsEXT& setSType( StructureType sType_ )
   18585     {
   18586       sType = sType_;
   18587       return *this;
   18588     }
   18589 
   18590     ValidationFlagsEXT& setPNext( const void* pNext_ )
   18591     {
   18592       pNext = pNext_;
   18593       return *this;
   18594     }
   18595 
   18596     ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
   18597     {
   18598       disabledValidationCheckCount = disabledValidationCheckCount_;
   18599       return *this;
   18600     }
   18601 
   18602     ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ )
   18603     {
   18604       pDisabledValidationChecks = pDisabledValidationChecks_;
   18605       return *this;
   18606     }
   18607 
   18608     operator const VkValidationFlagsEXT&() const
   18609     {
   18610       return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
   18611     }
   18612 
   18613     bool operator==( ValidationFlagsEXT const& rhs ) const
   18614     {
   18615       return ( sType == rhs.sType )
   18616           && ( pNext == rhs.pNext )
   18617           && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
   18618           && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
   18619     }
   18620 
   18621     bool operator!=( ValidationFlagsEXT const& rhs ) const
   18622     {
   18623       return !operator==( rhs );
   18624     }
   18625 
   18626   private:
   18627     StructureType sType;
   18628 
   18629   public:
   18630     const void* pNext;
   18631     uint32_t disabledValidationCheckCount;
   18632     ValidationCheckEXT* pDisabledValidationChecks;
   18633   };
   18634   static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
   18635 
   18636   inline Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance )
   18637   {
   18638     return static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
   18639   }
   18640 
   18641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18642   inline ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr )
   18643   {
   18644     Instance instance;
   18645     Result result = static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator)), reinterpret_cast<VkInstance*>( &instance ) ) );
   18646     return createResultValue( result, instance, "vk::createInstance" );
   18647   }
   18648 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18649 
   18650   inline Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties )
   18651   {
   18652     return static_cast<Result>( vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
   18653   }
   18654 
   18655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18656   template <typename Allocator = std::allocator<LayerProperties>>
   18657   typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties()
   18658   {
   18659     std::vector<LayerProperties,Allocator> properties;
   18660     uint32_t propertyCount;
   18661     Result result;
   18662     do
   18663     {
   18664       result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
   18665       if ( ( result == Result::eSuccess ) && propertyCount )
   18666       {
   18667         properties.resize( propertyCount );
   18668         result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
   18669       }
   18670     } while ( result == Result::eIncomplete );
   18671     assert( propertyCount <= properties.size() );
   18672     properties.resize( propertyCount );
   18673     return createResultValue( result, properties, "vk::enumerateInstanceLayerProperties" );
   18674   }
   18675 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18676 
   18677   inline Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties )
   18678   {
   18679     return static_cast<Result>( vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
   18680   }
   18681 
   18682 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   18683   template <typename Allocator = std::allocator<ExtensionProperties>>
   18684   typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr )
   18685   {
   18686     std::vector<ExtensionProperties,Allocator> properties;
   18687     uint32_t propertyCount;
   18688     Result result;
   18689     do
   18690     {
   18691       result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
   18692       if ( ( result == Result::eSuccess ) && propertyCount )
   18693       {
   18694         properties.resize( propertyCount );
   18695         result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
   18696       }
   18697     } while ( result == Result::eIncomplete );
   18698     assert( propertyCount <= properties.size() );
   18699     properties.resize( propertyCount );
   18700     return createResultValue( result, properties, "vk::enumerateInstanceExtensionProperties" );
   18701   }
   18702 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
   18703 
   18704   inline std::string to_string(FramebufferCreateFlagBits)
   18705   {
   18706     return "(void)";
   18707   }
   18708 
   18709   inline std::string to_string(FramebufferCreateFlags)
   18710   {
   18711     return "{}";
   18712   }
   18713 
   18714   inline std::string to_string(QueryPoolCreateFlagBits)
   18715   {
   18716     return "(void)";
   18717   }
   18718 
   18719   inline std::string to_string(QueryPoolCreateFlags)
   18720   {
   18721     return "{}";
   18722   }
   18723 
   18724   inline std::string to_string(RenderPassCreateFlagBits)
   18725   {
   18726     return "(void)";
   18727   }
   18728 
   18729   inline std::string to_string(RenderPassCreateFlags)
   18730   {
   18731     return "{}";
   18732   }
   18733 
   18734   inline std::string to_string(SamplerCreateFlagBits)
   18735   {
   18736     return "(void)";
   18737   }
   18738 
   18739   inline std::string to_string(SamplerCreateFlags)
   18740   {
   18741     return "{}";
   18742   }
   18743 
   18744   inline std::string to_string(PipelineLayoutCreateFlagBits)
   18745   {
   18746     return "(void)";
   18747   }
   18748 
   18749   inline std::string to_string(PipelineLayoutCreateFlags)
   18750   {
   18751     return "{}";
   18752   }
   18753 
   18754   inline std::string to_string(PipelineCacheCreateFlagBits)
   18755   {
   18756     return "(void)";
   18757   }
   18758 
   18759   inline std::string to_string(PipelineCacheCreateFlags)
   18760   {
   18761     return "{}";
   18762   }
   18763 
   18764   inline std::string to_string(PipelineDepthStencilStateCreateFlagBits)
   18765   {
   18766     return "(void)";
   18767   }
   18768 
   18769   inline std::string to_string(PipelineDepthStencilStateCreateFlags)
   18770   {
   18771     return "{}";
   18772   }
   18773 
   18774   inline std::string to_string(PipelineDynamicStateCreateFlagBits)
   18775   {
   18776     return "(void)";
   18777   }
   18778 
   18779   inline std::string to_string(PipelineDynamicStateCreateFlags)
   18780   {
   18781     return "{}";
   18782   }
   18783 
   18784   inline std::string to_string(PipelineColorBlendStateCreateFlagBits)
   18785   {
   18786     return "(void)";
   18787   }
   18788 
   18789   inline std::string to_string(PipelineColorBlendStateCreateFlags)
   18790   {
   18791     return "{}";
   18792   }
   18793 
   18794   inline std::string to_string(PipelineMultisampleStateCreateFlagBits)
   18795   {
   18796     return "(void)";
   18797   }
   18798 
   18799   inline std::string to_string(PipelineMultisampleStateCreateFlags)
   18800   {
   18801     return "{}";
   18802   }
   18803 
   18804   inline std::string to_string(PipelineRasterizationStateCreateFlagBits)
   18805   {
   18806     return "(void)";
   18807   }
   18808 
   18809   inline std::string to_string(PipelineRasterizationStateCreateFlags)
   18810   {
   18811     return "{}";
   18812   }
   18813 
   18814   inline std::string to_string(PipelineViewportStateCreateFlagBits)
   18815   {
   18816     return "(void)";
   18817   }
   18818 
   18819   inline std::string to_string(PipelineViewportStateCreateFlags)
   18820   {
   18821     return "{}";
   18822   }
   18823 
   18824   inline std::string to_string(PipelineTessellationStateCreateFlagBits)
   18825   {
   18826     return "(void)";
   18827   }
   18828 
   18829   inline std::string to_string(PipelineTessellationStateCreateFlags)
   18830   {
   18831     return "{}";
   18832   }
   18833 
   18834   inline std::string to_string(PipelineInputAssemblyStateCreateFlagBits)
   18835   {
   18836     return "(void)";
   18837   }
   18838 
   18839   inline std::string to_string(PipelineInputAssemblyStateCreateFlags)
   18840   {
   18841     return "{}";
   18842   }
   18843 
   18844   inline std::string to_string(PipelineVertexInputStateCreateFlagBits)
   18845   {
   18846     return "(void)";
   18847   }
   18848 
   18849   inline std::string to_string(PipelineVertexInputStateCreateFlags)
   18850   {
   18851     return "{}";
   18852   }
   18853 
   18854   inline std::string to_string(PipelineShaderStageCreateFlagBits)
   18855   {
   18856     return "(void)";
   18857   }
   18858 
   18859   inline std::string to_string(PipelineShaderStageCreateFlags)
   18860   {
   18861     return "{}";
   18862   }
   18863 
   18864   inline std::string to_string(DescriptorSetLayoutCreateFlagBits)
   18865   {
   18866     return "(void)";
   18867   }
   18868 
   18869   inline std::string to_string(DescriptorSetLayoutCreateFlags)
   18870   {
   18871     return "{}";
   18872   }
   18873 
   18874   inline std::string to_string(BufferViewCreateFlagBits)
   18875   {
   18876     return "(void)";
   18877   }
   18878 
   18879   inline std::string to_string(BufferViewCreateFlags)
   18880   {
   18881     return "{}";
   18882   }
   18883 
   18884   inline std::string to_string(InstanceCreateFlagBits)
   18885   {
   18886     return "(void)";
   18887   }
   18888 
   18889   inline std::string to_string(InstanceCreateFlags)
   18890   {
   18891     return "{}";
   18892   }
   18893 
   18894   inline std::string to_string(DeviceCreateFlagBits)
   18895   {
   18896     return "(void)";
   18897   }
   18898 
   18899   inline std::string to_string(DeviceCreateFlags)
   18900   {
   18901     return "{}";
   18902   }
   18903 
   18904   inline std::string to_string(DeviceQueueCreateFlagBits)
   18905   {
   18906     return "(void)";
   18907   }
   18908 
   18909   inline std::string to_string(DeviceQueueCreateFlags)
   18910   {
   18911     return "{}";
   18912   }
   18913 
   18914   inline std::string to_string(ImageViewCreateFlagBits)
   18915   {
   18916     return "(void)";
   18917   }
   18918 
   18919   inline std::string to_string(ImageViewCreateFlags)
   18920   {
   18921     return "{}";
   18922   }
   18923 
   18924   inline std::string to_string(SemaphoreCreateFlagBits)
   18925   {
   18926     return "(void)";
   18927   }
   18928 
   18929   inline std::string to_string(SemaphoreCreateFlags)
   18930   {
   18931     return "{}";
   18932   }
   18933 
   18934   inline std::string to_string(ShaderModuleCreateFlagBits)
   18935   {
   18936     return "(void)";
   18937   }
   18938 
   18939   inline std::string to_string(ShaderModuleCreateFlags)
   18940   {
   18941     return "{}";
   18942   }
   18943 
   18944   inline std::string to_string(EventCreateFlagBits)
   18945   {
   18946     return "(void)";
   18947   }
   18948 
   18949   inline std::string to_string(EventCreateFlags)
   18950   {
   18951     return "{}";
   18952   }
   18953 
   18954   inline std::string to_string(MemoryMapFlagBits)
   18955   {
   18956     return "(void)";
   18957   }
   18958 
   18959   inline std::string to_string(MemoryMapFlags)
   18960   {
   18961     return "{}";
   18962   }
   18963 
   18964   inline std::string to_string(SubpassDescriptionFlagBits)
   18965   {
   18966     return "(void)";
   18967   }
   18968 
   18969   inline std::string to_string(SubpassDescriptionFlags)
   18970   {
   18971     return "{}";
   18972   }
   18973 
   18974   inline std::string to_string(DescriptorPoolResetFlagBits)
   18975   {
   18976     return "(void)";
   18977   }
   18978 
   18979   inline std::string to_string(DescriptorPoolResetFlags)
   18980   {
   18981     return "{}";
   18982   }
   18983 
   18984   inline std::string to_string(SwapchainCreateFlagBitsKHR)
   18985   {
   18986     return "(void)";
   18987   }
   18988 
   18989   inline std::string to_string(SwapchainCreateFlagsKHR)
   18990   {
   18991     return "{}";
   18992   }
   18993 
   18994   inline std::string to_string(DisplayModeCreateFlagBitsKHR)
   18995   {
   18996     return "(void)";
   18997   }
   18998 
   18999   inline std::string to_string(DisplayModeCreateFlagsKHR)
   19000   {
   19001     return "{}";
   19002   }
   19003 
   19004   inline std::string to_string(DisplaySurfaceCreateFlagBitsKHR)
   19005   {
   19006     return "(void)";
   19007   }
   19008 
   19009   inline std::string to_string(DisplaySurfaceCreateFlagsKHR)
   19010   {
   19011     return "{}";
   19012   }
   19013 
   19014 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   19015   inline std::string to_string(AndroidSurfaceCreateFlagBitsKHR)
   19016   {
   19017     return "(void)";
   19018   }
   19019 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
   19020 
   19021 #ifdef VK_USE_PLATFORM_ANDROID_KHR
   19022   inline std::string to_string(AndroidSurfaceCreateFlagsKHR)
   19023   {
   19024     return "{}";
   19025   }
   19026 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
   19027 
   19028 #ifdef VK_USE_PLATFORM_MIR_KHR
   19029   inline std::string to_string(MirSurfaceCreateFlagBitsKHR)
   19030   {
   19031     return "(void)";
   19032   }
   19033 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   19034 
   19035 #ifdef VK_USE_PLATFORM_MIR_KHR
   19036   inline std::string to_string(MirSurfaceCreateFlagsKHR)
   19037   {
   19038     return "{}";
   19039   }
   19040 #endif /*VK_USE_PLATFORM_MIR_KHR*/
   19041 
   19042 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   19043   inline std::string to_string(WaylandSurfaceCreateFlagBitsKHR)
   19044   {
   19045     return "(void)";
   19046   }
   19047 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   19048 
   19049 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
   19050   inline std::string to_string(WaylandSurfaceCreateFlagsKHR)
   19051   {
   19052     return "{}";
   19053   }
   19054 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
   19055 
   19056 #ifdef VK_USE_PLATFORM_WIN32_KHR
   19057   inline std::string to_string(Win32SurfaceCreateFlagBitsKHR)
   19058   {
   19059     return "(void)";
   19060   }
   19061 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   19062 
   19063 #ifdef VK_USE_PLATFORM_WIN32_KHR
   19064   inline std::string to_string(Win32SurfaceCreateFlagsKHR)
   19065   {
   19066     return "{}";
   19067   }
   19068 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
   19069 
   19070 #ifdef VK_USE_PLATFORM_XLIB_KHR
   19071   inline std::string to_string(XlibSurfaceCreateFlagBitsKHR)
   19072   {
   19073     return "(void)";
   19074   }
   19075 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   19076 
   19077 #ifdef VK_USE_PLATFORM_XLIB_KHR
   19078   inline std::string to_string(XlibSurfaceCreateFlagsKHR)
   19079   {
   19080     return "{}";
   19081   }
   19082 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
   19083 
   19084 #ifdef VK_USE_PLATFORM_XCB_KHR
   19085   inline std::string to_string(XcbSurfaceCreateFlagBitsKHR)
   19086   {
   19087     return "(void)";
   19088   }
   19089 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   19090 
   19091 #ifdef VK_USE_PLATFORM_XCB_KHR
   19092   inline std::string to_string(XcbSurfaceCreateFlagsKHR)
   19093   {
   19094     return "{}";
   19095   }
   19096 #endif /*VK_USE_PLATFORM_XCB_KHR*/
   19097 
   19098   inline std::string to_string(ImageLayout value)
   19099   {
   19100     switch (value)
   19101     {
   19102     case ImageLayout::eUndefined: return "Undefined";
   19103     case ImageLayout::eGeneral: return "General";
   19104     case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal";
   19105     case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal";
   19106     case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal";
   19107     case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal";
   19108     case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal";
   19109     case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal";
   19110     case ImageLayout::ePreinitialized: return "Preinitialized";
   19111     case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR";
   19112     default: return "invalid";
   19113     }
   19114   }
   19115 
   19116   inline std::string to_string(AttachmentLoadOp value)
   19117   {
   19118     switch (value)
   19119     {
   19120     case AttachmentLoadOp::eLoad: return "Load";
   19121     case AttachmentLoadOp::eClear: return "Clear";
   19122     case AttachmentLoadOp::eDontCare: return "DontCare";
   19123     default: return "invalid";
   19124     }
   19125   }
   19126 
   19127   inline std::string to_string(AttachmentStoreOp value)
   19128   {
   19129     switch (value)
   19130     {
   19131     case AttachmentStoreOp::eStore: return "Store";
   19132     case AttachmentStoreOp::eDontCare: return "DontCare";
   19133     default: return "invalid";
   19134     }
   19135   }
   19136 
   19137   inline std::string to_string(ImageType value)
   19138   {
   19139     switch (value)
   19140     {
   19141     case ImageType::e1D: return "1D";
   19142     case ImageType::e2D: return "2D";
   19143     case ImageType::e3D: return "3D";
   19144     default: return "invalid";
   19145     }
   19146   }
   19147 
   19148   inline std::string to_string(ImageTiling value)
   19149   {
   19150     switch (value)
   19151     {
   19152     case ImageTiling::eOptimal: return "Optimal";
   19153     case ImageTiling::eLinear: return "Linear";
   19154     default: return "invalid";
   19155     }
   19156   }
   19157 
   19158   inline std::string to_string(ImageViewType value)
   19159   {
   19160     switch (value)
   19161     {
   19162     case ImageViewType::e1D: return "1D";
   19163     case ImageViewType::e2D: return "2D";
   19164     case ImageViewType::e3D: return "3D";
   19165     case ImageViewType::eCube: return "Cube";
   19166     case ImageViewType::e1DArray: return "1DArray";
   19167     case ImageViewType::e2DArray: return "2DArray";
   19168     case ImageViewType::eCubeArray: return "CubeArray";
   19169     default: return "invalid";
   19170     }
   19171   }
   19172 
   19173   inline std::string to_string(CommandBufferLevel value)
   19174   {
   19175     switch (value)
   19176     {
   19177     case CommandBufferLevel::ePrimary: return "Primary";
   19178     case CommandBufferLevel::eSecondary: return "Secondary";
   19179     default: return "invalid";
   19180     }
   19181   }
   19182 
   19183   inline std::string to_string(ComponentSwizzle value)
   19184   {
   19185     switch (value)
   19186     {
   19187     case ComponentSwizzle::eIdentity: return "Identity";
   19188     case ComponentSwizzle::eZero: return "Zero";
   19189     case ComponentSwizzle::eOne: return "One";
   19190     case ComponentSwizzle::eR: return "R";
   19191     case ComponentSwizzle::eG: return "G";
   19192     case ComponentSwizzle::eB: return "B";
   19193     case ComponentSwizzle::eA: return "A";
   19194     default: return "invalid";
   19195     }
   19196   }
   19197 
   19198   inline std::string to_string(DescriptorType value)
   19199   {
   19200     switch (value)
   19201     {
   19202     case DescriptorType::eSampler: return "Sampler";
   19203     case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler";
   19204     case DescriptorType::eSampledImage: return "SampledImage";
   19205     case DescriptorType::eStorageImage: return "StorageImage";
   19206     case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer";
   19207     case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer";
   19208     case DescriptorType::eUniformBuffer: return "UniformBuffer";
   19209     case DescriptorType::eStorageBuffer: return "StorageBuffer";
   19210     case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic";
   19211     case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic";
   19212     case DescriptorType::eInputAttachment: return "InputAttachment";
   19213     default: return "invalid";
   19214     }
   19215   }
   19216 
   19217   inline std::string to_string(QueryType value)
   19218   {
   19219     switch (value)
   19220     {
   19221     case QueryType::eOcclusion: return "Occlusion";
   19222     case QueryType::ePipelineStatistics: return "PipelineStatistics";
   19223     case QueryType::eTimestamp: return "Timestamp";
   19224     default: return "invalid";
   19225     }
   19226   }
   19227 
   19228   inline std::string to_string(BorderColor value)
   19229   {
   19230     switch (value)
   19231     {
   19232     case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack";
   19233     case BorderColor::eIntTransparentBlack: return "IntTransparentBlack";
   19234     case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack";
   19235     case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack";
   19236     case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite";
   19237     case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite";
   19238     default: return "invalid";
   19239     }
   19240   }
   19241 
   19242   inline std::string to_string(PipelineBindPoint value)
   19243   {
   19244     switch (value)
   19245     {
   19246     case PipelineBindPoint::eGraphics: return "Graphics";
   19247     case PipelineBindPoint::eCompute: return "Compute";
   19248     default: return "invalid";
   19249     }
   19250   }
   19251 
   19252   inline std::string to_string(PipelineCacheHeaderVersion value)
   19253   {
   19254     switch (value)
   19255     {
   19256     case PipelineCacheHeaderVersion::eOne: return "One";
   19257     default: return "invalid";
   19258     }
   19259   }
   19260 
   19261   inline std::string to_string(PrimitiveTopology value)
   19262   {
   19263     switch (value)
   19264     {
   19265     case PrimitiveTopology::ePointList: return "PointList";
   19266     case PrimitiveTopology::eLineList: return "LineList";
   19267     case PrimitiveTopology::eLineStrip: return "LineStrip";
   19268     case PrimitiveTopology::eTriangleList: return "TriangleList";
   19269     case PrimitiveTopology::eTriangleStrip: return "TriangleStrip";
   19270     case PrimitiveTopology::eTriangleFan: return "TriangleFan";
   19271     case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency";
   19272     case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency";
   19273     case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency";
   19274     case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency";
   19275     case PrimitiveTopology::ePatchList: return "PatchList";
   19276     default: return "invalid";
   19277     }
   19278   }
   19279 
   19280   inline std::string to_string(SharingMode value)
   19281   {
   19282     switch (value)
   19283     {
   19284     case SharingMode::eExclusive: return "Exclusive";
   19285     case SharingMode::eConcurrent: return "Concurrent";
   19286     default: return "invalid";
   19287     }
   19288   }
   19289 
   19290   inline std::string to_string(IndexType value)
   19291   {
   19292     switch (value)
   19293     {
   19294     case IndexType::eUint16: return "Uint16";
   19295     case IndexType::eUint32: return "Uint32";
   19296     default: return "invalid";
   19297     }
   19298   }
   19299 
   19300   inline std::string to_string(Filter value)
   19301   {
   19302     switch (value)
   19303     {
   19304     case Filter::eNearest: return "Nearest";
   19305     case Filter::eLinear: return "Linear";
   19306     case Filter::eCubicIMG: return "CubicIMG";
   19307     default: return "invalid";
   19308     }
   19309   }
   19310 
   19311   inline std::string to_string(SamplerMipmapMode value)
   19312   {
   19313     switch (value)
   19314     {
   19315     case SamplerMipmapMode::eNearest: return "Nearest";
   19316     case SamplerMipmapMode::eLinear: return "Linear";
   19317     default: return "invalid";
   19318     }
   19319   }
   19320 
   19321   inline std::string to_string(SamplerAddressMode value)
   19322   {
   19323     switch (value)
   19324     {
   19325     case SamplerAddressMode::eRepeat: return "Repeat";
   19326     case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat";
   19327     case SamplerAddressMode::eClampToEdge: return "ClampToEdge";
   19328     case SamplerAddressMode::eClampToBorder: return "ClampToBorder";
   19329     case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge";
   19330     default: return "invalid";
   19331     }
   19332   }
   19333 
   19334   inline std::string to_string(CompareOp value)
   19335   {
   19336     switch (value)
   19337     {
   19338     case CompareOp::eNever: return "Never";
   19339     case CompareOp::eLess: return "Less";
   19340     case CompareOp::eEqual: return "Equal";
   19341     case CompareOp::eLessOrEqual: return "LessOrEqual";
   19342     case CompareOp::eGreater: return "Greater";
   19343     case CompareOp::eNotEqual: return "NotEqual";
   19344     case CompareOp::eGreaterOrEqual: return "GreaterOrEqual";
   19345     case CompareOp::eAlways: return "Always";
   19346     default: return "invalid";
   19347     }
   19348   }
   19349 
   19350   inline std::string to_string(PolygonMode value)
   19351   {
   19352     switch (value)
   19353     {
   19354     case PolygonMode::eFill: return "Fill";
   19355     case PolygonMode::eLine: return "Line";
   19356     case PolygonMode::ePoint: return "Point";
   19357     default: return "invalid";
   19358     }
   19359   }
   19360 
   19361   inline std::string to_string(CullModeFlagBits value)
   19362   {
   19363     switch (value)
   19364     {
   19365     case CullModeFlagBits::eNone: return "None";
   19366     case CullModeFlagBits::eFront: return "Front";
   19367     case CullModeFlagBits::eBack: return "Back";
   19368     case CullModeFlagBits::eFrontAndBack: return "FrontAndBack";
   19369     default: return "invalid";
   19370     }
   19371   }
   19372 
   19373   inline std::string to_string(CullModeFlags value)
   19374   {
   19375     if (!value) return "{}";
   19376     std::string result;
   19377     if (value & CullModeFlagBits::eNone) result += "None | ";
   19378     if (value & CullModeFlagBits::eFront) result += "Front | ";
   19379     if (value & CullModeFlagBits::eBack) result += "Back | ";
   19380     if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | ";
   19381     return "{" + result.substr(0, result.size() - 3) + "}";
   19382   }
   19383 
   19384   inline std::string to_string(FrontFace value)
   19385   {
   19386     switch (value)
   19387     {
   19388     case FrontFace::eCounterClockwise: return "CounterClockwise";
   19389     case FrontFace::eClockwise: return "Clockwise";
   19390     default: return "invalid";
   19391     }
   19392   }
   19393 
   19394   inline std::string to_string(BlendFactor value)
   19395   {
   19396     switch (value)
   19397     {
   19398     case BlendFactor::eZero: return "Zero";
   19399     case BlendFactor::eOne: return "One";
   19400     case BlendFactor::eSrcColor: return "SrcColor";
   19401     case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor";
   19402     case BlendFactor::eDstColor: return "DstColor";
   19403     case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor";
   19404     case BlendFactor::eSrcAlpha: return "SrcAlpha";
   19405     case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha";
   19406     case BlendFactor::eDstAlpha: return "DstAlpha";
   19407     case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha";
   19408     case BlendFactor::eConstantColor: return "ConstantColor";
   19409     case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor";
   19410     case BlendFactor::eConstantAlpha: return "ConstantAlpha";
   19411     case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha";
   19412     case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate";
   19413     case BlendFactor::eSrc1Color: return "Src1Color";
   19414     case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color";
   19415     case BlendFactor::eSrc1Alpha: return "Src1Alpha";
   19416     case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha";
   19417     default: return "invalid";
   19418     }
   19419   }
   19420 
   19421   inline std::string to_string(BlendOp value)
   19422   {
   19423     switch (value)
   19424     {
   19425     case BlendOp::eAdd: return "Add";
   19426     case BlendOp::eSubtract: return "Subtract";
   19427     case BlendOp::eReverseSubtract: return "ReverseSubtract";
   19428     case BlendOp::eMin: return "Min";
   19429     case BlendOp::eMax: return "Max";
   19430     default: return "invalid";
   19431     }
   19432   }
   19433 
   19434   inline std::string to_string(StencilOp value)
   19435   {
   19436     switch (value)
   19437     {
   19438     case StencilOp::eKeep: return "Keep";
   19439     case StencilOp::eZero: return "Zero";
   19440     case StencilOp::eReplace: return "Replace";
   19441     case StencilOp::eIncrementAndClamp: return "IncrementAndClamp";
   19442     case StencilOp::eDecrementAndClamp: return "DecrementAndClamp";
   19443     case StencilOp::eInvert: return "Invert";
   19444     case StencilOp::eIncrementAndWrap: return "IncrementAndWrap";
   19445     case StencilOp::eDecrementAndWrap: return "DecrementAndWrap";
   19446     default: return "invalid";
   19447     }
   19448   }
   19449 
   19450   inline std::string to_string(LogicOp value)
   19451   {
   19452     switch (value)
   19453     {
   19454     case LogicOp::eClear: return "Clear";
   19455     case LogicOp::eAnd: return "And";
   19456     case LogicOp::eAndReverse: return "AndReverse";
   19457     case LogicOp::eCopy: return "Copy";
   19458     case LogicOp::eAndInverted: return "AndInverted";
   19459     case LogicOp::eNoOp: return "NoOp";
   19460     case LogicOp::eXor: return "Xor";
   19461     case LogicOp::eOr: return "Or";
   19462     case LogicOp::eNor: return "Nor";
   19463     case LogicOp::eEquivalent: return "Equivalent";
   19464     case LogicOp::eInvert: return "Invert";
   19465     case LogicOp::eOrReverse: return "OrReverse";
   19466     case LogicOp::eCopyInverted: return "CopyInverted";
   19467     case LogicOp::eOrInverted: return "OrInverted";
   19468     case LogicOp::eNand: return "Nand";
   19469     case LogicOp::eSet: return "Set";
   19470     default: return "invalid";
   19471     }
   19472   }
   19473 
   19474   inline std::string to_string(InternalAllocationType value)
   19475   {
   19476     switch (value)
   19477     {
   19478     case InternalAllocationType::eExecutable: return "Executable";
   19479     default: return "invalid";
   19480     }
   19481   }
   19482 
   19483   inline std::string to_string(SystemAllocationScope value)
   19484   {
   19485     switch (value)
   19486     {
   19487     case SystemAllocationScope::eCommand: return "Command";
   19488     case SystemAllocationScope::eObject: return "Object";
   19489     case SystemAllocationScope::eCache: return "Cache";
   19490     case SystemAllocationScope::eDevice: return "Device";
   19491     case SystemAllocationScope::eInstance: return "Instance";
   19492     default: return "invalid";
   19493     }
   19494   }
   19495 
   19496   inline std::string to_string(PhysicalDeviceType value)
   19497   {
   19498     switch (value)
   19499     {
   19500     case PhysicalDeviceType::eOther: return "Other";
   19501     case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu";
   19502     case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu";
   19503     case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu";
   19504     case PhysicalDeviceType::eCpu: return "Cpu";
   19505     default: return "invalid";
   19506     }
   19507   }
   19508 
   19509   inline std::string to_string(VertexInputRate value)
   19510   {
   19511     switch (value)
   19512     {
   19513     case VertexInputRate::eVertex: return "Vertex";
   19514     case VertexInputRate::eInstance: return "Instance";
   19515     default: return "invalid";
   19516     }
   19517   }
   19518 
   19519   inline std::string to_string(Format value)
   19520   {
   19521     switch (value)
   19522     {
   19523     case Format::eUndefined: return "Undefined";
   19524     case Format::eR4G4UnormPack8: return "R4G4UnormPack8";
   19525     case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16";
   19526     case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16";
   19527     case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16";
   19528     case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16";
   19529     case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16";
   19530     case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16";
   19531     case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16";
   19532     case Format::eR8Unorm: return "R8Unorm";
   19533     case Format::eR8Snorm: return "R8Snorm";
   19534     case Format::eR8Uscaled: return "R8Uscaled";
   19535     case Format::eR8Sscaled: return "R8Sscaled";
   19536     case Format::eR8Uint: return "R8Uint";
   19537     case Format::eR8Sint: return "R8Sint";
   19538     case Format::eR8Srgb: return "R8Srgb";
   19539     case Format::eR8G8Unorm: return "R8G8Unorm";
   19540     case Format::eR8G8Snorm: return "R8G8Snorm";
   19541     case Format::eR8G8Uscaled: return "R8G8Uscaled";
   19542     case Format::eR8G8Sscaled: return "R8G8Sscaled";
   19543     case Format::eR8G8Uint: return "R8G8Uint";
   19544     case Format::eR8G8Sint: return "R8G8Sint";
   19545     case Format::eR8G8Srgb: return "R8G8Srgb";
   19546     case Format::eR8G8B8Unorm: return "R8G8B8Unorm";
   19547     case Format::eR8G8B8Snorm: return "R8G8B8Snorm";
   19548     case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled";
   19549     case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled";
   19550     case Format::eR8G8B8Uint: return "R8G8B8Uint";
   19551     case Format::eR8G8B8Sint: return "R8G8B8Sint";
   19552     case Format::eR8G8B8Srgb: return "R8G8B8Srgb";
   19553     case Format::eB8G8R8Unorm: return "B8G8R8Unorm";
   19554     case Format::eB8G8R8Snorm: return "B8G8R8Snorm";
   19555     case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled";
   19556     case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled";
   19557     case Format::eB8G8R8Uint: return "B8G8R8Uint";
   19558     case Format::eB8G8R8Sint: return "B8G8R8Sint";
   19559     case Format::eB8G8R8Srgb: return "B8G8R8Srgb";
   19560     case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm";
   19561     case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm";
   19562     case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled";
   19563     case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled";
   19564     case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint";
   19565     case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint";
   19566     case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb";
   19567     case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm";
   19568     case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm";
   19569     case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled";
   19570     case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled";
   19571     case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint";
   19572     case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint";
   19573     case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb";
   19574     case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32";
   19575     case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32";
   19576     case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32";
   19577     case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32";
   19578     case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32";
   19579     case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32";
   19580     case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32";
   19581     case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32";
   19582     case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32";
   19583     case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32";
   19584     case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32";
   19585     case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32";
   19586     case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32";
   19587     case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32";
   19588     case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32";
   19589     case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32";
   19590     case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32";
   19591     case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32";
   19592     case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32";
   19593     case Format::eR16Unorm: return "R16Unorm";
   19594     case Format::eR16Snorm: return "R16Snorm";
   19595     case Format::eR16Uscaled: return "R16Uscaled";
   19596     case Format::eR16Sscaled: return "R16Sscaled";
   19597     case Format::eR16Uint: return "R16Uint";
   19598     case Format::eR16Sint: return "R16Sint";
   19599     case Format::eR16Sfloat: return "R16Sfloat";
   19600     case Format::eR16G16Unorm: return "R16G16Unorm";
   19601     case Format::eR16G16Snorm: return "R16G16Snorm";
   19602     case Format::eR16G16Uscaled: return "R16G16Uscaled";
   19603     case Format::eR16G16Sscaled: return "R16G16Sscaled";
   19604     case Format::eR16G16Uint: return "R16G16Uint";
   19605     case Format::eR16G16Sint: return "R16G16Sint";
   19606     case Format::eR16G16Sfloat: return "R16G16Sfloat";
   19607     case Format::eR16G16B16Unorm: return "R16G16B16Unorm";
   19608     case Format::eR16G16B16Snorm: return "R16G16B16Snorm";
   19609     case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled";
   19610     case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled";
   19611     case Format::eR16G16B16Uint: return "R16G16B16Uint";
   19612     case Format::eR16G16B16Sint: return "R16G16B16Sint";
   19613     case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat";
   19614     case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm";
   19615     case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm";
   19616     case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled";
   19617     case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled";
   19618     case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint";
   19619     case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint";
   19620     case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat";
   19621     case Format::eR32Uint: return "R32Uint";
   19622     case Format::eR32Sint: return "R32Sint";
   19623     case Format::eR32Sfloat: return "R32Sfloat";
   19624     case Format::eR32G32Uint: return "R32G32Uint";
   19625     case Format::eR32G32Sint: return "R32G32Sint";
   19626     case Format::eR32G32Sfloat: return "R32G32Sfloat";
   19627     case Format::eR32G32B32Uint: return "R32G32B32Uint";
   19628     case Format::eR32G32B32Sint: return "R32G32B32Sint";
   19629     case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat";
   19630     case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint";
   19631     case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint";
   19632     case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat";
   19633     case Format::eR64Uint: return "R64Uint";
   19634     case Format::eR64Sint: return "R64Sint";
   19635     case Format::eR64Sfloat: return "R64Sfloat";
   19636     case Format::eR64G64Uint: return "R64G64Uint";
   19637     case Format::eR64G64Sint: return "R64G64Sint";
   19638     case Format::eR64G64Sfloat: return "R64G64Sfloat";
   19639     case Format::eR64G64B64Uint: return "R64G64B64Uint";
   19640     case Format::eR64G64B64Sint: return "R64G64B64Sint";
   19641     case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat";
   19642     case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint";
   19643     case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint";
   19644     case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat";
   19645     case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32";
   19646     case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32";
   19647     case Format::eD16Unorm: return "D16Unorm";
   19648     case Format::eX8D24UnormPack32: return "X8D24UnormPack32";
   19649     case Format::eD32Sfloat: return "D32Sfloat";
   19650     case Format::eS8Uint: return "S8Uint";
   19651     case Format::eD16UnormS8Uint: return "D16UnormS8Uint";
   19652     case Format::eD24UnormS8Uint: return "D24UnormS8Uint";
   19653     case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint";
   19654     case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock";
   19655     case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock";
   19656     case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock";
   19657     case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock";
   19658     case Format::eBc2UnormBlock: return "Bc2UnormBlock";
   19659     case Format::eBc2SrgbBlock: return "Bc2SrgbBlock";
   19660     case Format::eBc3UnormBlock: return "Bc3UnormBlock";
   19661     case Format::eBc3SrgbBlock: return "Bc3SrgbBlock";
   19662     case Format::eBc4UnormBlock: return "Bc4UnormBlock";
   19663     case Format::eBc4SnormBlock: return "Bc4SnormBlock";
   19664     case Format::eBc5UnormBlock: return "Bc5UnormBlock";
   19665     case Format::eBc5SnormBlock: return "Bc5SnormBlock";
   19666     case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock";
   19667     case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock";
   19668     case Format::eBc7UnormBlock: return "Bc7UnormBlock";
   19669     case Format::eBc7SrgbBlock: return "Bc7SrgbBlock";
   19670     case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock";
   19671     case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock";
   19672     case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock";
   19673     case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock";
   19674     case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock";
   19675     case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock";
   19676     case Format::eEacR11UnormBlock: return "EacR11UnormBlock";
   19677     case Format::eEacR11SnormBlock: return "EacR11SnormBlock";
   19678     case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock";
   19679     case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock";
   19680     case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock";
   19681     case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock";
   19682     case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock";
   19683     case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock";
   19684     case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock";
   19685     case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock";
   19686     case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock";
   19687     case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock";
   19688     case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock";
   19689     case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock";
   19690     case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock";
   19691     case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock";
   19692     case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock";
   19693     case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock";
   19694     case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock";
   19695     case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock";
   19696     case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock";
   19697     case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock";
   19698     case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock";
   19699     case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock";
   19700     case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock";
   19701     case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock";
   19702     case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock";
   19703     case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock";
   19704     case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock";
   19705     case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock";
   19706     case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock";
   19707     case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock";
   19708     case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG";
   19709     case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG";
   19710     case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG";
   19711     case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG";
   19712     case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG";
   19713     case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG";
   19714     case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG";
   19715     case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG";
   19716     default: return "invalid";
   19717     }
   19718   }
   19719 
   19720   inline std::string to_string(StructureType value)
   19721   {
   19722     switch (value)
   19723     {
   19724     case StructureType::eApplicationInfo: return "ApplicationInfo";
   19725     case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo";
   19726     case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo";
   19727     case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo";
   19728     case StructureType::eSubmitInfo: return "SubmitInfo";
   19729     case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo";
   19730     case StructureType::eMappedMemoryRange: return "MappedMemoryRange";
   19731     case StructureType::eBindSparseInfo: return "BindSparseInfo";
   19732     case StructureType::eFenceCreateInfo: return "FenceCreateInfo";
   19733     case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo";
   19734     case StructureType::eEventCreateInfo: return "EventCreateInfo";
   19735     case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo";
   19736     case StructureType::eBufferCreateInfo: return "BufferCreateInfo";
   19737     case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo";
   19738     case StructureType::eImageCreateInfo: return "ImageCreateInfo";
   19739     case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo";
   19740     case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo";
   19741     case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo";
   19742     case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo";
   19743     case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo";
   19744     case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo";
   19745     case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo";
   19746     case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo";
   19747     case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo";
   19748     case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo";
   19749     case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo";
   19750     case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo";
   19751     case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo";
   19752     case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo";
   19753     case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo";
   19754     case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo";
   19755     case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo";
   19756     case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo";
   19757     case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo";
   19758     case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo";
   19759     case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet";
   19760     case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet";
   19761     case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo";
   19762     case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo";
   19763     case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo";
   19764     case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo";
   19765     case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo";
   19766     case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo";
   19767     case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo";
   19768     case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier";
   19769     case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier";
   19770     case StructureType::eMemoryBarrier: return "MemoryBarrier";
   19771     case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo";
   19772     case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo";
   19773     case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR";
   19774     case StructureType::ePresentInfoKHR: return "PresentInfoKHR";
   19775     case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR";
   19776     case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR";
   19777     case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR";
   19778     case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR";
   19779     case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR";
   19780     case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR";
   19781     case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR";
   19782     case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR";
   19783     case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR";
   19784     case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT";
   19785     case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD";
   19786     case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT";
   19787     case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT";
   19788     case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT";
   19789     case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
   19790     case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
   19791     case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
   19792     case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
   19793     case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
   19794     case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
   19795     case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV";
   19796     case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV";
   19797     case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
   19798     default: return "invalid";
   19799     }
   19800   }
   19801 
   19802   inline std::string to_string(SubpassContents value)
   19803   {
   19804     switch (value)
   19805     {
   19806     case SubpassContents::eInline: return "Inline";
   19807     case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
   19808     default: return "invalid";
   19809     }
   19810   }
   19811 
   19812   inline std::string to_string(DynamicState value)
   19813   {
   19814     switch (value)
   19815     {
   19816     case DynamicState::eViewport: return "Viewport";
   19817     case DynamicState::eScissor: return "Scissor";
   19818     case DynamicState::eLineWidth: return "LineWidth";
   19819     case DynamicState::eDepthBias: return "DepthBias";
   19820     case DynamicState::eBlendConstants: return "BlendConstants";
   19821     case DynamicState::eDepthBounds: return "DepthBounds";
   19822     case DynamicState::eStencilCompareMask: return "StencilCompareMask";
   19823     case DynamicState::eStencilWriteMask: return "StencilWriteMask";
   19824     case DynamicState::eStencilReference: return "StencilReference";
   19825     default: return "invalid";
   19826     }
   19827   }
   19828 
   19829   inline std::string to_string(QueueFlagBits value)
   19830   {
   19831     switch (value)
   19832     {
   19833     case QueueFlagBits::eGraphics: return "Graphics";
   19834     case QueueFlagBits::eCompute: return "Compute";
   19835     case QueueFlagBits::eTransfer: return "Transfer";
   19836     case QueueFlagBits::eSparseBinding: return "SparseBinding";
   19837     default: return "invalid";
   19838     }
   19839   }
   19840 
   19841   inline std::string to_string(QueueFlags value)
   19842   {
   19843     if (!value) return "{}";
   19844     std::string result;
   19845     if (value & QueueFlagBits::eGraphics) result += "Graphics | ";
   19846     if (value & QueueFlagBits::eCompute) result += "Compute | ";
   19847     if (value & QueueFlagBits::eTransfer) result += "Transfer | ";
   19848     if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | ";
   19849     return "{" + result.substr(0, result.size() - 3) + "}";
   19850   }
   19851 
   19852   inline std::string to_string(MemoryPropertyFlagBits value)
   19853   {
   19854     switch (value)
   19855     {
   19856     case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal";
   19857     case MemoryPropertyFlagBits::eHostVisible: return "HostVisible";
   19858     case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent";
   19859     case MemoryPropertyFlagBits::eHostCached: return "HostCached";
   19860     case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated";
   19861     default: return "invalid";
   19862     }
   19863   }
   19864 
   19865   inline std::string to_string(MemoryPropertyFlags value)
   19866   {
   19867     if (!value) return "{}";
   19868     std::string result;
   19869     if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | ";
   19870     if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | ";
   19871     if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | ";
   19872     if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | ";
   19873     if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | ";
   19874     return "{" + result.substr(0, result.size() - 3) + "}";
   19875   }
   19876 
   19877   inline std::string to_string(MemoryHeapFlagBits value)
   19878   {
   19879     switch (value)
   19880     {
   19881     case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal";
   19882     default: return "invalid";
   19883     }
   19884   }
   19885 
   19886   inline std::string to_string(MemoryHeapFlags value)
   19887   {
   19888     if (!value) return "{}";
   19889     std::string result;
   19890     if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | ";
   19891     return "{" + result.substr(0, result.size() - 3) + "}";
   19892   }
   19893 
   19894   inline std::string to_string(AccessFlagBits value)
   19895   {
   19896     switch (value)
   19897     {
   19898     case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead";
   19899     case AccessFlagBits::eIndexRead: return "IndexRead";
   19900     case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead";
   19901     case AccessFlagBits::eUniformRead: return "UniformRead";
   19902     case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead";
   19903     case AccessFlagBits::eShaderRead: return "ShaderRead";
   19904     case AccessFlagBits::eShaderWrite: return "ShaderWrite";
   19905     case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead";
   19906     case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite";
   19907     case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead";
   19908     case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite";
   19909     case AccessFlagBits::eTransferRead: return "TransferRead";
   19910     case AccessFlagBits::eTransferWrite: return "TransferWrite";
   19911     case AccessFlagBits::eHostRead: return "HostRead";
   19912     case AccessFlagBits::eHostWrite: return "HostWrite";
   19913     case AccessFlagBits::eMemoryRead: return "MemoryRead";
   19914     case AccessFlagBits::eMemoryWrite: return "MemoryWrite";
   19915     default: return "invalid";
   19916     }
   19917   }
   19918 
   19919   inline std::string to_string(AccessFlags value)
   19920   {
   19921     if (!value) return "{}";
   19922     std::string result;
   19923     if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | ";
   19924     if (value & AccessFlagBits::eIndexRead) result += "IndexRead | ";
   19925     if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | ";
   19926     if (value & AccessFlagBits::eUniformRead) result += "UniformRead | ";
   19927     if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | ";
   19928     if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | ";
   19929     if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | ";
   19930     if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | ";
   19931     if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | ";
   19932     if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | ";
   19933     if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | ";
   19934     if (value & AccessFlagBits::eTransferRead) result += "TransferRead | ";
   19935     if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | ";
   19936     if (value & AccessFlagBits::eHostRead) result += "HostRead | ";
   19937     if (value & AccessFlagBits::eHostWrite) result += "HostWrite | ";
   19938     if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | ";
   19939     if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | ";
   19940     return "{" + result.substr(0, result.size() - 3) + "}";
   19941   }
   19942 
   19943   inline std::string to_string(BufferUsageFlagBits value)
   19944   {
   19945     switch (value)
   19946     {
   19947     case BufferUsageFlagBits::eTransferSrc: return "TransferSrc";
   19948     case BufferUsageFlagBits::eTransferDst: return "TransferDst";
   19949     case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
   19950     case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
   19951     case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer";
   19952     case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer";
   19953     case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer";
   19954     case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer";
   19955     case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer";
   19956     default: return "invalid";
   19957     }
   19958   }
   19959 
   19960   inline std::string to_string(BufferUsageFlags value)
   19961   {
   19962     if (!value) return "{}";
   19963     std::string result;
   19964     if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
   19965     if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | ";
   19966     if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
   19967     if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
   19968     if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | ";
   19969     if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | ";
   19970     if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | ";
   19971     if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | ";
   19972     if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | ";
   19973     return "{" + result.substr(0, result.size() - 3) + "}";
   19974   }
   19975 
   19976   inline std::string to_string(BufferCreateFlagBits value)
   19977   {
   19978     switch (value)
   19979     {
   19980     case BufferCreateFlagBits::eSparseBinding: return "SparseBinding";
   19981     case BufferCreateFlagBits::eSparseResidency: return "SparseResidency";
   19982     case BufferCreateFlagBits::eSparseAliased: return "SparseAliased";
   19983     default: return "invalid";
   19984     }
   19985   }
   19986 
   19987   inline std::string to_string(BufferCreateFlags value)
   19988   {
   19989     if (!value) return "{}";
   19990     std::string result;
   19991     if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
   19992     if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
   19993     if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
   19994     return "{" + result.substr(0, result.size() - 3) + "}";
   19995   }
   19996 
   19997   inline std::string to_string(ShaderStageFlagBits value)
   19998   {
   19999     switch (value)
   20000     {
   20001     case ShaderStageFlagBits::eVertex: return "Vertex";
   20002     case ShaderStageFlagBits::eTessellationControl: return "TessellationControl";
   20003     case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation";
   20004     case ShaderStageFlagBits::eGeometry: return "Geometry";
   20005     case ShaderStageFlagBits::eFragment: return "Fragment";
   20006     case ShaderStageFlagBits::eCompute: return "Compute";
   20007     case ShaderStageFlagBits::eAllGraphics: return "AllGraphics";
   20008     case ShaderStageFlagBits::eAll: return "All";
   20009     default: return "invalid";
   20010     }
   20011   }
   20012 
   20013   inline std::string to_string(ShaderStageFlags value)
   20014   {
   20015     if (!value) return "{}";
   20016     std::string result;
   20017     if (value & ShaderStageFlagBits::eVertex) result += "Vertex | ";
   20018     if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | ";
   20019     if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | ";
   20020     if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | ";
   20021     if (value & ShaderStageFlagBits::eFragment) result += "Fragment | ";
   20022     if (value & ShaderStageFlagBits::eCompute) result += "Compute | ";
   20023     if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | ";
   20024     if (value & ShaderStageFlagBits::eAll) result += "All | ";
   20025     return "{" + result.substr(0, result.size() - 3) + "}";
   20026   }
   20027 
   20028   inline std::string to_string(ImageUsageFlagBits value)
   20029   {
   20030     switch (value)
   20031     {
   20032     case ImageUsageFlagBits::eTransferSrc: return "TransferSrc";
   20033     case ImageUsageFlagBits::eTransferDst: return "TransferDst";
   20034     case ImageUsageFlagBits::eSampled: return "Sampled";
   20035     case ImageUsageFlagBits::eStorage: return "Storage";
   20036     case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment";
   20037     case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
   20038     case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment";
   20039     case ImageUsageFlagBits::eInputAttachment: return "InputAttachment";
   20040     default: return "invalid";
   20041     }
   20042   }
   20043 
   20044   inline std::string to_string(ImageUsageFlags value)
   20045   {
   20046     if (!value) return "{}";
   20047     std::string result;
   20048     if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
   20049     if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | ";
   20050     if (value & ImageUsageFlagBits::eSampled) result += "Sampled | ";
   20051     if (value & ImageUsageFlagBits::eStorage) result += "Storage | ";
   20052     if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | ";
   20053     if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
   20054     if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | ";
   20055     if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | ";
   20056     return "{" + result.substr(0, result.size() - 3) + "}";
   20057   }
   20058 
   20059   inline std::string to_string(ImageCreateFlagBits value)
   20060   {
   20061     switch (value)
   20062     {
   20063     case ImageCreateFlagBits::eSparseBinding: return "SparseBinding";
   20064     case ImageCreateFlagBits::eSparseResidency: return "SparseResidency";
   20065     case ImageCreateFlagBits::eSparseAliased: return "SparseAliased";
   20066     case ImageCreateFlagBits::eMutableFormat: return "MutableFormat";
   20067     case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible";
   20068     default: return "invalid";
   20069     }
   20070   }
   20071 
   20072   inline std::string to_string(ImageCreateFlags value)
   20073   {
   20074     if (!value) return "{}";
   20075     std::string result;
   20076     if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
   20077     if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
   20078     if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
   20079     if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | ";
   20080     if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | ";
   20081     return "{" + result.substr(0, result.size() - 3) + "}";
   20082   }
   20083 
   20084   inline std::string to_string(PipelineCreateFlagBits value)
   20085   {
   20086     switch (value)
   20087     {
   20088     case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization";
   20089     case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives";
   20090     case PipelineCreateFlagBits::eDerivative: return "Derivative";
   20091     default: return "invalid";
   20092     }
   20093   }
   20094 
   20095   inline std::string to_string(PipelineCreateFlags value)
   20096   {
   20097     if (!value) return "{}";
   20098     std::string result;
   20099     if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | ";
   20100     if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | ";
   20101     if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | ";
   20102     return "{" + result.substr(0, result.size() - 3) + "}";
   20103   }
   20104 
   20105   inline std::string to_string(ColorComponentFlagBits value)
   20106   {
   20107     switch (value)
   20108     {
   20109     case ColorComponentFlagBits::eR: return "R";
   20110     case ColorComponentFlagBits::eG: return "G";
   20111     case ColorComponentFlagBits::eB: return "B";
   20112     case ColorComponentFlagBits::eA: return "A";
   20113     default: return "invalid";
   20114     }
   20115   }
   20116 
   20117   inline std::string to_string(ColorComponentFlags value)
   20118   {
   20119     if (!value) return "{}";
   20120     std::string result;
   20121     if (value & ColorComponentFlagBits::eR) result += "R | ";
   20122     if (value & ColorComponentFlagBits::eG) result += "G | ";
   20123     if (value & ColorComponentFlagBits::eB) result += "B | ";
   20124     if (value & ColorComponentFlagBits::eA) result += "A | ";
   20125     return "{" + result.substr(0, result.size() - 3) + "}";
   20126   }
   20127 
   20128   inline std::string to_string(FenceCreateFlagBits value)
   20129   {
   20130     switch (value)
   20131     {
   20132     case FenceCreateFlagBits::eSignaled: return "Signaled";
   20133     default: return "invalid";
   20134     }
   20135   }
   20136 
   20137   inline std::string to_string(FenceCreateFlags value)
   20138   {
   20139     if (!value) return "{}";
   20140     std::string result;
   20141     if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | ";
   20142     return "{" + result.substr(0, result.size() - 3) + "}";
   20143   }
   20144 
   20145   inline std::string to_string(FormatFeatureFlagBits value)
   20146   {
   20147     switch (value)
   20148     {
   20149     case FormatFeatureFlagBits::eSampledImage: return "SampledImage";
   20150     case FormatFeatureFlagBits::eStorageImage: return "StorageImage";
   20151     case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic";
   20152     case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
   20153     case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
   20154     case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic";
   20155     case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer";
   20156     case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment";
   20157     case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend";
   20158     case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
   20159     case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc";
   20160     case FormatFeatureFlagBits::eBlitDst: return "BlitDst";
   20161     case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear";
   20162     case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG";
   20163     default: return "invalid";
   20164     }
   20165   }
   20166 
   20167   inline std::string to_string(FormatFeatureFlags value)
   20168   {
   20169     if (!value) return "{}";
   20170     std::string result;
   20171     if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | ";
   20172     if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | ";
   20173     if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | ";
   20174     if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
   20175     if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
   20176     if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | ";
   20177     if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | ";
   20178     if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | ";
   20179     if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | ";
   20180     if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
   20181     if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | ";
   20182     if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | ";
   20183     if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | ";
   20184     if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | ";
   20185     return "{" + result.substr(0, result.size() - 3) + "}";
   20186   }
   20187 
   20188   inline std::string to_string(QueryControlFlagBits value)
   20189   {
   20190     switch (value)
   20191     {
   20192     case QueryControlFlagBits::ePrecise: return "Precise";
   20193     default: return "invalid";
   20194     }
   20195   }
   20196 
   20197   inline std::string to_string(QueryControlFlags value)
   20198   {
   20199     if (!value) return "{}";
   20200     std::string result;
   20201     if (value & QueryControlFlagBits::ePrecise) result += "Precise | ";
   20202     return "{" + result.substr(0, result.size() - 3) + "}";
   20203   }
   20204 
   20205   inline std::string to_string(QueryResultFlagBits value)
   20206   {
   20207     switch (value)
   20208     {
   20209     case QueryResultFlagBits::e64: return "64";
   20210     case QueryResultFlagBits::eWait: return "Wait";
   20211     case QueryResultFlagBits::eWithAvailability: return "WithAvailability";
   20212     case QueryResultFlagBits::ePartial: return "Partial";
   20213     default: return "invalid";
   20214     }
   20215   }
   20216 
   20217   inline std::string to_string(QueryResultFlags value)
   20218   {
   20219     if (!value) return "{}";
   20220     std::string result;
   20221     if (value & QueryResultFlagBits::e64) result += "64 | ";
   20222     if (value & QueryResultFlagBits::eWait) result += "Wait | ";
   20223     if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | ";
   20224     if (value & QueryResultFlagBits::ePartial) result += "Partial | ";
   20225     return "{" + result.substr(0, result.size() - 3) + "}";
   20226   }
   20227 
   20228   inline std::string to_string(CommandBufferUsageFlagBits value)
   20229   {
   20230     switch (value)
   20231     {
   20232     case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit";
   20233     case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue";
   20234     case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse";
   20235     default: return "invalid";
   20236     }
   20237   }
   20238 
   20239   inline std::string to_string(CommandBufferUsageFlags value)
   20240   {
   20241     if (!value) return "{}";
   20242     std::string result;
   20243     if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | ";
   20244     if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | ";
   20245     if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | ";
   20246     return "{" + result.substr(0, result.size() - 3) + "}";
   20247   }
   20248 
   20249   inline std::string to_string(QueryPipelineStatisticFlagBits value)
   20250   {
   20251     switch (value)
   20252     {
   20253     case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices";
   20254     case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives";
   20255     case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations";
   20256     case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations";
   20257     case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives";
   20258     case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations";
   20259     case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives";
   20260     case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations";
   20261     case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches";
   20262     case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations";
   20263     case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations";
   20264     default: return "invalid";
   20265     }
   20266   }
   20267 
   20268   inline std::string to_string(QueryPipelineStatisticFlags value)
   20269   {
   20270     if (!value) return "{}";
   20271     std::string result;
   20272     if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | ";
   20273     if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | ";
   20274     if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | ";
   20275     if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | ";
   20276     if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | ";
   20277     if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | ";
   20278     if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | ";
   20279     if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | ";
   20280     if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | ";
   20281     if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | ";
   20282     if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | ";
   20283     return "{" + result.substr(0, result.size() - 3) + "}";
   20284   }
   20285 
   20286   inline std::string to_string(ImageAspectFlagBits value)
   20287   {
   20288     switch (value)
   20289     {
   20290     case ImageAspectFlagBits::eColor: return "Color";
   20291     case ImageAspectFlagBits::eDepth: return "Depth";
   20292     case ImageAspectFlagBits::eStencil: return "Stencil";
   20293     case ImageAspectFlagBits::eMetadata: return "Metadata";
   20294     default: return "invalid";
   20295     }
   20296   }
   20297 
   20298   inline std::string to_string(ImageAspectFlags value)
   20299   {
   20300     if (!value) return "{}";
   20301     std::string result;
   20302     if (value & ImageAspectFlagBits::eColor) result += "Color | ";
   20303     if (value & ImageAspectFlagBits::eDepth) result += "Depth | ";
   20304     if (value & ImageAspectFlagBits::eStencil) result += "Stencil | ";
   20305     if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | ";
   20306     return "{" + result.substr(0, result.size() - 3) + "}";
   20307   }
   20308 
   20309   inline std::string to_string(SparseImageFormatFlagBits value)
   20310   {
   20311     switch (value)
   20312     {
   20313     case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail";
   20314     case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize";
   20315     case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize";
   20316     default: return "invalid";
   20317     }
   20318   }
   20319 
   20320   inline std::string to_string(SparseImageFormatFlags value)
   20321   {
   20322     if (!value) return "{}";
   20323     std::string result;
   20324     if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | ";
   20325     if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | ";
   20326     if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | ";
   20327     return "{" + result.substr(0, result.size() - 3) + "}";
   20328   }
   20329 
   20330   inline std::string to_string(SparseMemoryBindFlagBits value)
   20331   {
   20332     switch (value)
   20333     {
   20334     case SparseMemoryBindFlagBits::eMetadata: return "Metadata";
   20335     default: return "invalid";
   20336     }
   20337   }
   20338 
   20339   inline std::string to_string(SparseMemoryBindFlags value)
   20340   {
   20341     if (!value) return "{}";
   20342     std::string result;
   20343     if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | ";
   20344     return "{" + result.substr(0, result.size() - 3) + "}";
   20345   }
   20346 
   20347   inline std::string to_string(PipelineStageFlagBits value)
   20348   {
   20349     switch (value)
   20350     {
   20351     case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe";
   20352     case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect";
   20353     case PipelineStageFlagBits::eVertexInput: return "VertexInput";
   20354     case PipelineStageFlagBits::eVertexShader: return "VertexShader";
   20355     case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader";
   20356     case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader";
   20357     case PipelineStageFlagBits::eGeometryShader: return "GeometryShader";
   20358     case PipelineStageFlagBits::eFragmentShader: return "FragmentShader";
   20359     case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests";
   20360     case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests";
   20361     case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput";
   20362     case PipelineStageFlagBits::eComputeShader: return "ComputeShader";
   20363     case PipelineStageFlagBits::eTransfer: return "Transfer";
   20364     case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe";
   20365     case PipelineStageFlagBits::eHost: return "Host";
   20366     case PipelineStageFlagBits::eAllGraphics: return "AllGraphics";
   20367     case PipelineStageFlagBits::eAllCommands: return "AllCommands";
   20368     default: return "invalid";
   20369     }
   20370   }
   20371 
   20372   inline std::string to_string(PipelineStageFlags value)
   20373   {
   20374     if (!value) return "{}";
   20375     std::string result;
   20376     if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | ";
   20377     if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | ";
   20378     if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | ";
   20379     if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | ";
   20380     if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | ";
   20381     if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | ";
   20382     if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | ";
   20383     if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | ";
   20384     if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | ";
   20385     if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | ";
   20386     if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | ";
   20387     if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | ";
   20388     if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | ";
   20389     if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | ";
   20390     if (value & PipelineStageFlagBits::eHost) result += "Host | ";
   20391     if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | ";
   20392     if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | ";
   20393     return "{" + result.substr(0, result.size() - 3) + "}";
   20394   }
   20395 
   20396   inline std::string to_string(CommandPoolCreateFlagBits value)
   20397   {
   20398     switch (value)
   20399     {
   20400     case CommandPoolCreateFlagBits::eTransient: return "Transient";
   20401     case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer";
   20402     default: return "invalid";
   20403     }
   20404   }
   20405 
   20406   inline std::string to_string(CommandPoolCreateFlags value)
   20407   {
   20408     if (!value) return "{}";
   20409     std::string result;
   20410     if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | ";
   20411     if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | ";
   20412     return "{" + result.substr(0, result.size() - 3) + "}";
   20413   }
   20414 
   20415   inline std::string to_string(CommandPoolResetFlagBits value)
   20416   {
   20417     switch (value)
   20418     {
   20419     case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources";
   20420     default: return "invalid";
   20421     }
   20422   }
   20423 
   20424   inline std::string to_string(CommandPoolResetFlags value)
   20425   {
   20426     if (!value) return "{}";
   20427     std::string result;
   20428     if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
   20429     return "{" + result.substr(0, result.size() - 3) + "}";
   20430   }
   20431 
   20432   inline std::string to_string(CommandBufferResetFlagBits value)
   20433   {
   20434     switch (value)
   20435     {
   20436     case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources";
   20437     default: return "invalid";
   20438     }
   20439   }
   20440 
   20441   inline std::string to_string(CommandBufferResetFlags value)
   20442   {
   20443     if (!value) return "{}";
   20444     std::string result;
   20445     if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
   20446     return "{" + result.substr(0, result.size() - 3) + "}";
   20447   }
   20448 
   20449   inline std::string to_string(SampleCountFlagBits value)
   20450   {
   20451     switch (value)
   20452     {
   20453     case SampleCountFlagBits::e1: return "1";
   20454     case SampleCountFlagBits::e2: return "2";
   20455     case SampleCountFlagBits::e4: return "4";
   20456     case SampleCountFlagBits::e8: return "8";
   20457     case SampleCountFlagBits::e16: return "16";
   20458     case SampleCountFlagBits::e32: return "32";
   20459     case SampleCountFlagBits::e64: return "64";
   20460     default: return "invalid";
   20461     }
   20462   }
   20463 
   20464   inline std::string to_string(SampleCountFlags value)
   20465   {
   20466     if (!value) return "{}";
   20467     std::string result;
   20468     if (value & SampleCountFlagBits::e1) result += "1 | ";
   20469     if (value & SampleCountFlagBits::e2) result += "2 | ";
   20470     if (value & SampleCountFlagBits::e4) result += "4 | ";
   20471     if (value & SampleCountFlagBits::e8) result += "8 | ";
   20472     if (value & SampleCountFlagBits::e16) result += "16 | ";
   20473     if (value & SampleCountFlagBits::e32) result += "32 | ";
   20474     if (value & SampleCountFlagBits::e64) result += "64 | ";
   20475     return "{" + result.substr(0, result.size() - 3) + "}";
   20476   }
   20477 
   20478   inline std::string to_string(AttachmentDescriptionFlagBits value)
   20479   {
   20480     switch (value)
   20481     {
   20482     case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias";
   20483     default: return "invalid";
   20484     }
   20485   }
   20486 
   20487   inline std::string to_string(AttachmentDescriptionFlags value)
   20488   {
   20489     if (!value) return "{}";
   20490     std::string result;
   20491     if (value & AttachmentDescriptionFlagBits::eMayAlias) result += "MayAlias | ";
   20492     return "{" + result.substr(0, result.size() - 3) + "}";
   20493   }
   20494 
   20495   inline std::string to_string(StencilFaceFlagBits value)
   20496   {
   20497     switch (value)
   20498     {
   20499     case StencilFaceFlagBits::eFront: return "Front";
   20500     case StencilFaceFlagBits::eBack: return "Back";
   20501     case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack";
   20502     default: return "invalid";
   20503     }
   20504   }
   20505 
   20506   inline std::string to_string(StencilFaceFlags value)
   20507   {
   20508     if (!value) return "{}";
   20509     std::string result;
   20510     if (value & StencilFaceFlagBits::eFront) result += "Front | ";
   20511     if (value & StencilFaceFlagBits::eBack) result += "Back | ";
   20512     if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | ";
   20513     return "{" + result.substr(0, result.size() - 3) + "}";
   20514   }
   20515 
   20516   inline std::string to_string(DescriptorPoolCreateFlagBits value)
   20517   {
   20518     switch (value)
   20519     {
   20520     case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
   20521     default: return "invalid";
   20522     }
   20523   }
   20524 
   20525   inline std::string to_string(DescriptorPoolCreateFlags value)
   20526   {
   20527     if (!value) return "{}";
   20528     std::string result;
   20529     if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | ";
   20530     return "{" + result.substr(0, result.size() - 3) + "}";
   20531   }
   20532 
   20533   inline std::string to_string(DependencyFlagBits value)
   20534   {
   20535     switch (value)
   20536     {
   20537     case DependencyFlagBits::eByRegion: return "ByRegion";
   20538     default: return "invalid";
   20539     }
   20540   }
   20541 
   20542   inline std::string to_string(DependencyFlags value)
   20543   {
   20544     if (!value) return "{}";
   20545     std::string result;
   20546     if (value & DependencyFlagBits::eByRegion) result += "ByRegion | ";
   20547     return "{" + result.substr(0, result.size() - 3) + "}";
   20548   }
   20549 
   20550   inline std::string to_string(PresentModeKHR value)
   20551   {
   20552     switch (value)
   20553     {
   20554     case PresentModeKHR::eImmediate: return "Immediate";
   20555     case PresentModeKHR::eMailbox: return "Mailbox";
   20556     case PresentModeKHR::eFifo: return "Fifo";
   20557     case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed";
   20558     default: return "invalid";
   20559     }
   20560   }
   20561 
   20562   inline std::string to_string(ColorSpaceKHR value)
   20563   {
   20564     switch (value)
   20565     {
   20566     case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear";
   20567     default: return "invalid";
   20568     }
   20569   }
   20570 
   20571   inline std::string to_string(DisplayPlaneAlphaFlagBitsKHR value)
   20572   {
   20573     switch (value)
   20574     {
   20575     case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque";
   20576     case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global";
   20577     case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel";
   20578     case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied";
   20579     default: return "invalid";
   20580     }
   20581   }
   20582 
   20583   inline std::string to_string(DisplayPlaneAlphaFlagsKHR value)
   20584   {
   20585     if (!value) return "{}";
   20586     std::string result;
   20587     if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
   20588     if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal) result += "Global | ";
   20589     if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel) result += "PerPixel | ";
   20590     if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | ";
   20591     return "{" + result.substr(0, result.size() - 3) + "}";
   20592   }
   20593 
   20594   inline std::string to_string(CompositeAlphaFlagBitsKHR value)
   20595   {
   20596     switch (value)
   20597     {
   20598     case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque";
   20599     case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied";
   20600     case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied";
   20601     case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit";
   20602     default: return "invalid";
   20603     }
   20604   }
   20605 
   20606   inline std::string to_string(CompositeAlphaFlagsKHR value)
   20607   {
   20608     if (!value) return "{}";
   20609     std::string result;
   20610     if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
   20611     if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | ";
   20612     if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | ";
   20613     if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | ";
   20614     return "{" + result.substr(0, result.size() - 3) + "}";
   20615   }
   20616 
   20617   inline std::string to_string(SurfaceTransformFlagBitsKHR value)
   20618   {
   20619     switch (value)
   20620     {
   20621     case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity";
   20622     case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90";
   20623     case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180";
   20624     case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270";
   20625     case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror";
   20626     case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90";
   20627     case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180";
   20628     case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270";
   20629     case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit";
   20630     default: return "invalid";
   20631     }
   20632   }
   20633 
   20634   inline std::string to_string(SurfaceTransformFlagsKHR value)
   20635   {
   20636     if (!value) return "{}";
   20637     std::string result;
   20638     if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | ";
   20639     if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | ";
   20640     if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | ";
   20641     if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | ";
   20642     if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | ";
   20643     if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | ";
   20644     if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | ";
   20645     if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | ";
   20646     if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | ";
   20647     return "{" + result.substr(0, result.size() - 3) + "}";
   20648   }
   20649 
   20650   inline std::string to_string(DebugReportFlagBitsEXT value)
   20651   {
   20652     switch (value)
   20653     {
   20654     case DebugReportFlagBitsEXT::eInformation: return "Information";
   20655     case DebugReportFlagBitsEXT::eWarning: return "Warning";
   20656     case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning";
   20657     case DebugReportFlagBitsEXT::eError: return "Error";
   20658     case DebugReportFlagBitsEXT::eDebug: return "Debug";
   20659     default: return "invalid";
   20660     }
   20661   }
   20662 
   20663   inline std::string to_string(DebugReportFlagsEXT value)
   20664   {
   20665     if (!value) return "{}";
   20666     std::string result;
   20667     if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | ";
   20668     if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | ";
   20669     if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | ";
   20670     if (value & DebugReportFlagBitsEXT::eError) result += "Error | ";
   20671     if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | ";
   20672     return "{" + result.substr(0, result.size() - 3) + "}";
   20673   }
   20674 
   20675   inline std::string to_string(DebugReportObjectTypeEXT value)
   20676   {
   20677     switch (value)
   20678     {
   20679     case DebugReportObjectTypeEXT::eUnknown: return "Unknown";
   20680     case DebugReportObjectTypeEXT::eInstance: return "Instance";
   20681     case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice";
   20682     case DebugReportObjectTypeEXT::eDevice: return "Device";
   20683     case DebugReportObjectTypeEXT::eQueue: return "Queue";
   20684     case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore";
   20685     case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer";
   20686     case DebugReportObjectTypeEXT::eFence: return "Fence";
   20687     case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory";
   20688     case DebugReportObjectTypeEXT::eBuffer: return "Buffer";
   20689     case DebugReportObjectTypeEXT::eImage: return "Image";
   20690     case DebugReportObjectTypeEXT::eEvent: return "Event";
   20691     case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool";
   20692     case DebugReportObjectTypeEXT::eBufferView: return "BufferView";
   20693     case DebugReportObjectTypeEXT::eImageView: return "ImageView";
   20694     case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule";
   20695     case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache";
   20696     case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout";
   20697     case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass";
   20698     case DebugReportObjectTypeEXT::ePipeline: return "Pipeline";
   20699     case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout";
   20700     case DebugReportObjectTypeEXT::eSampler: return "Sampler";
   20701     case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool";
   20702     case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet";
   20703     case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer";
   20704     case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool";
   20705     case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr";
   20706     case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr";
   20707     case DebugReportObjectTypeEXT::eDebugReport: return "DebugReport";
   20708     default: return "invalid";
   20709     }
   20710   }
   20711 
   20712   inline std::string to_string(DebugReportErrorEXT value)
   20713   {
   20714     switch (value)
   20715     {
   20716     case DebugReportErrorEXT::eNone: return "None";
   20717     case DebugReportErrorEXT::eCallbackRef: return "CallbackRef";
   20718     default: return "invalid";
   20719     }
   20720   }
   20721 
   20722   inline std::string to_string(RasterizationOrderAMD value)
   20723   {
   20724     switch (value)
   20725     {
   20726     case RasterizationOrderAMD::eStrict: return "Strict";
   20727     case RasterizationOrderAMD::eRelaxed: return "Relaxed";
   20728     default: return "invalid";
   20729     }
   20730   }
   20731 
   20732   inline std::string to_string(ExternalMemoryHandleTypeFlagBitsNV value)
   20733   {
   20734     switch (value)
   20735     {
   20736     case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32";
   20737     case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
   20738     case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image";
   20739     case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt";
   20740     default: return "invalid";
   20741     }
   20742   }
   20743 
   20744   inline std::string to_string(ExternalMemoryHandleTypeFlagsNV value)
   20745   {
   20746     if (!value) return "{}";
   20747     std::string result;
   20748     if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) result += "OpaqueWin32 | ";
   20749     if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
   20750     if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) result += "D3D11Image | ";
   20751     if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) result += "D3D11ImageKmt | ";
   20752     return "{" + result.substr(0, result.size() - 3) + "}";
   20753   }
   20754 
   20755   inline std::string to_string(ExternalMemoryFeatureFlagBitsNV value)
   20756   {
   20757     switch (value)
   20758     {
   20759     case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly";
   20760     case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable";
   20761     case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable";
   20762     default: return "invalid";
   20763     }
   20764   }
   20765 
   20766   inline std::string to_string(ExternalMemoryFeatureFlagsNV value)
   20767   {
   20768     if (!value) return "{}";
   20769     std::string result;
   20770     if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) result += "DedicatedOnly | ";
   20771     if (value & ExternalMemoryFeatureFlagBitsNV::eExportable) result += "Exportable | ";
   20772     if (value & ExternalMemoryFeatureFlagBitsNV::eImportable) result += "Importable | ";
   20773     return "{" + result.substr(0, result.size() - 3) + "}";
   20774   }
   20775 
   20776   inline std::string to_string(ValidationCheckEXT value)
   20777   {
   20778     switch (value)
   20779     {
   20780     case ValidationCheckEXT::eAll: return "All";
   20781     default: return "invalid";
   20782     }
   20783   }
   20784 
   20785 } // namespace vk
   20786 
   20787 #endif
   20788