Vulkan header update
Update Vulkan headers to ToT
Includes VK_EXT_line_rasterization
Bug: b/139800520
Change-Id: I054c32a29bc740679b4286818e2bac70701ef07c
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/37408
Presubmit-Ready: Alexis Hétu <sugoi@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
Tested-by: Alexis Hétu <sugoi@google.com>
diff --git a/include/vulkan/vk_icd.h b/include/vulkan/vk_icd.h
index a511d81..e42f40c 100644
--- a/include/vulkan/vk_icd.h
+++ b/include/vulkan/vk_icd.h
@@ -89,7 +89,8 @@
VK_ICD_WSI_PLATFORM_MACOS,
VK_ICD_WSI_PLATFORM_IOS,
VK_ICD_WSI_PLATFORM_DISPLAY,
- VK_ICD_WSI_PLATFORM_HEADLESS
+ VK_ICD_WSI_PLATFORM_HEADLESS,
+ VK_ICD_WSI_PLATFORM_METAL,
} VkIcdWsiPlatform;
typedef struct {
@@ -172,4 +173,11 @@
VkIcdSurfaceBase base;
} VkIcdSurfaceHeadless;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+typedef struct {
+ VkIcdSurfaceBase base;
+ const CAMetalLayer *pLayer;
+} VkIcdSurfaceMetal;
+#endif // VK_USE_PLATFORM_METAL_EXT
+
#endif // VKICD_H
diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h
index a468393..375964b 100644
--- a/include/vulkan/vulkan.h
+++ b/include/vulkan/vulkan.h
@@ -27,7 +27,6 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
#include <zircon/types.h>
#include "vulkan_fuchsia.h"
-#include "vulkan_fuchsia_extras.h"
#endif
#ifdef VK_USE_PLATFORM_IOS_MVK
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 75a10ba..17cc6fe 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -56,7 +56,11 @@
# define VULKAN_HPP_ASSERT assert
#endif
-static_assert( VK_HEADER_VERSION == 111 , "Wrong VK_HEADER_VERSION!" );
+#if defined(__linux__)
+# include <dlfcn.h>
+#endif
+
+static_assert( VK_HEADER_VERSION == 125 , "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -100,7 +104,7 @@
#endif
#if !defined(VULKAN_HPP_INLINE)
-# if defined(__clang___)
+# if defined(__clang__)
# if __has_attribute(always_inline)
# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
# else
@@ -121,10 +125,18 @@
# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
#endif
-#if defined(_MSC_VER) && (_MSC_VER <= 1800)
-# define VULKAN_HPP_CONSTEXPR
-#else
+#if defined(__cpp_constexpr)
# define VULKAN_HPP_CONSTEXPR constexpr
+# if __cpp_constexpr >= 201304
+# define VULKAN_HPP_CONSTEXPR_14 constexpr
+# else
+# define VULKAN_HPP_CONSTEXPR_14
+# endif
+# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
+#else
+# define VULKAN_HPP_CONSTEXPR
+# define VULKAN_HPP_CONSTEXPR_14
+# define VULKAN_HPP_CONST_OR_CONSTEXPR const
#endif
#if !defined(VULKAN_HPP_NAMESPACE)
@@ -240,23 +252,19 @@
public:
VULKAN_HPP_CONSTEXPR Flags()
: m_mask(0)
- {
- }
+ {}
- Flags(BitType bit)
+ VULKAN_HPP_CONSTEXPR Flags(BitType bit)
: m_mask(static_cast<MaskType>(bit))
- {
- }
+ {}
- Flags(Flags<BitType> const& rhs)
+ VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const& rhs)
: m_mask(rhs.m_mask)
- {
- }
+ {}
- explicit Flags(MaskType flags)
+ VULKAN_HPP_CONSTEXPR explicit Flags(MaskType flags)
: m_mask(flags)
- {
- }
+ {}
Flags<BitType> & operator=(Flags<BitType> const& rhs)
{
@@ -282,55 +290,47 @@
return *this;
}
- Flags<BitType> operator|(Flags<BitType> const& rhs) const
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const& rhs) const
{
- Flags<BitType> result(*this);
- result |= rhs;
- return result;
+ return Flags<BitType>(m_mask | rhs.m_mask);
}
- Flags<BitType> operator&(Flags<BitType> const& rhs) const
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const& rhs) const
{
- Flags<BitType> result(*this);
- result &= rhs;
- return result;
+ return Flags<BitType>(m_mask & rhs.m_mask);
}
- Flags<BitType> operator^(Flags<BitType> const& rhs) const
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const& rhs) const
{
- Flags<BitType> result(*this);
- result ^= rhs;
- return result;
+ return Flags<BitType>(m_mask ^ rhs.m_mask);
}
- bool operator!() const
+ VULKAN_HPP_CONSTEXPR bool operator!() const
{
return !m_mask;
}
- Flags<BitType> operator~() const
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const
{
- Flags<BitType> result(*this);
- result.m_mask ^= FlagTraits<BitType>::allFlags;
- return result;
+ return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags);
}
- bool operator==(Flags<BitType> const& rhs) const
+ VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const& rhs) const
{
return m_mask == rhs.m_mask;
}
- bool operator!=(Flags<BitType> const& rhs) const
+ VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const& rhs) const
{
return m_mask != rhs.m_mask;
}
- explicit operator bool() const
+ explicit VULKAN_HPP_CONSTEXPR operator bool() const
{
return !!m_mask;
}
- explicit operator MaskType() const
+ explicit VULKAN_HPP_CONSTEXPR operator MaskType() const
{
return m_mask;
}
@@ -340,23 +340,35 @@
};
template <typename BitType>
- Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags)
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags)
{
return flags | bit;
}
template <typename BitType>
- Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags)
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags)
{
return flags & bit;
}
template <typename BitType>
- Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags)
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags)
{
return flags ^ bit;
}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const& flags)
+ {
+ return flags == bit;
+ }
+
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const& flags)
+ {
+ return flags != bit;
+ }
+
template <typename RefType>
class Optional
{
@@ -1013,6 +1025,11 @@
return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
}
+ void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const
+ {
+ return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
+ }
+
void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const
{
return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
@@ -1749,6 +1766,21 @@
return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
}
+ VkResult vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations ) const
+ {
+ return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
+ }
+
+ VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties ) const
+ {
+ return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
+ }
+
+ VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics ) const
+ {
+ return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
+ }
+
VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const
{
return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
@@ -1769,6 +1801,11 @@
return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
}
+ VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t* pValue ) const
+ {
+ return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
+ }
+
VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const
{
return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
@@ -1932,6 +1969,11 @@
return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
}
+ VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo ) const
+ {
+ return ::vkSignalSemaphoreKHR( device, pSignalInfo );
+ }
+
void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
{
return ::vkTrimCommandPool( device, commandPool, flags );
@@ -1977,6 +2019,11 @@
return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
}
+ VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout ) const
+ {
+ return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
+ }
+
#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
{
@@ -2493,11 +2540,34 @@
return ::vkQueueWaitIdle( queue );
}
};
+#endif
- typedef DispatchLoaderStatic DispatchLoaderDefault;
-#else // !defined(VK_NO_PROTOTYPES)
- class NeedExplicitDispatchLoader;
- typedef NeedExplicitDispatchLoader DispatchLoaderDefault;
+ class DispatchLoaderDynamic;
+#if !defined(VULKAN_HPP_DISPATCH_LOADER_DYNAMIC)
+# if defined(VK_NO_PROTOTYPES)
+# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
+# else
+# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
+# endif
+#endif
+
+#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER)
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+# define VULKAN_HPP_DEFAULT_DISPATCHER ::vk::defaultDispatchLoaderDynamic
+# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE namespace vk { DispatchLoaderDynamic defaultDispatchLoaderDynamic; }
+ extern DispatchLoaderDynamic defaultDispatchLoaderDynamic;
+# else
+# define VULKAN_HPP_DEFAULT_DISPATCHER ::vk::DispatchLoaderStatic()
+# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+# endif
+#endif
+
+#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER_TYPE)
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+ #define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::vk::DispatchLoaderDynamic
+# else
+# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::vk::DispatchLoaderStatic
+# endif
#endif
struct AllocationCallbacks;
@@ -2506,7 +2576,7 @@
class ObjectDestroy
{
public:
- ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+ ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER )
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
@@ -2534,7 +2604,7 @@
class ObjectDestroy<NoParent,Dispatch>
{
public:
- ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+ ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER )
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{}
@@ -2557,7 +2627,7 @@
class ObjectFree
{
public:
- ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
+ ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER )
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
@@ -2583,7 +2653,7 @@
class PoolFree
{
public:
- PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = Dispatch() )
+ PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = VULKAN_HPP_DEFAULT_DISPATCHER )
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
@@ -2605,6 +2675,24 @@
Dispatch const* m_dispatch;
};
+ template <typename T, size_t N, size_t I>
+ class ConstExpressionArrayCopy
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR_14 static void copy(T dst[N], std::array<T,N> const& src)
+ {
+ dst[I-1] = src[I-1];
+ ConstExpressionArrayCopy<T, N, I - 1>::copy(dst, src);
+ }
+ };
+
+ template <typename T, size_t N>
+ class ConstExpressionArrayCopy<T, N, 0>
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR_14 static void copy(T /*dst*/[N], std::array<T,N> const& /*src*/) {}
+ };
+
using Bool32 = uint32_t;
using DeviceAddress = uint64_t;
using DeviceSize = uint64_t;
@@ -3361,7 +3449,8 @@
eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR,
eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY_KHR,
eGoogleSwiftshader = VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR,
- eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY_KHR
+ eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY_KHR,
+ eBroadcomProprietary = VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR
};
VULKAN_HPP_INLINE std::string to_string( DriverIdKHR value )
@@ -3379,6 +3468,7 @@
case DriverIdKHR::eArmProprietary : return "ArmProprietary";
case DriverIdKHR::eGoogleSwiftshader : return "GoogleSwiftshader";
case DriverIdKHR::eGgpProprietary : return "GgpProprietary";
+ case DriverIdKHR::eBroadcomProprietary : return "BroadcomProprietary";
default: return "invalid";
}
}
@@ -3399,7 +3489,8 @@
eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT,
eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
- eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
+ eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV,
+ eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT
};
VULKAN_HPP_INLINE std::string to_string( DynamicState value )
@@ -3421,6 +3512,7 @@
case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV";
case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV";
case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV";
+ case DynamicState::eLineStippleEXT : return "LineStippleEXT";
default: return "invalid";
}
}
@@ -3673,6 +3765,20 @@
ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
+ eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT,
+ eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT,
+ eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT,
+ eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT,
+ eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT,
+ eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT,
+ eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT,
+ eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT,
+ eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT,
+ eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT,
+ eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT,
+ eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT,
+ eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT,
+ eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT,
eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
@@ -3940,6 +4046,20 @@
case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG";
case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG";
case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG";
+ case Format::eAstc4x4SfloatBlockEXT : return "Astc4x4SfloatBlockEXT";
+ case Format::eAstc5x4SfloatBlockEXT : return "Astc5x4SfloatBlockEXT";
+ case Format::eAstc5x5SfloatBlockEXT : return "Astc5x5SfloatBlockEXT";
+ case Format::eAstc6x5SfloatBlockEXT : return "Astc6x5SfloatBlockEXT";
+ case Format::eAstc6x6SfloatBlockEXT : return "Astc6x6SfloatBlockEXT";
+ case Format::eAstc8x5SfloatBlockEXT : return "Astc8x5SfloatBlockEXT";
+ case Format::eAstc8x6SfloatBlockEXT : return "Astc8x6SfloatBlockEXT";
+ case Format::eAstc8x8SfloatBlockEXT : return "Astc8x8SfloatBlockEXT";
+ case Format::eAstc10x5SfloatBlockEXT : return "Astc10x5SfloatBlockEXT";
+ case Format::eAstc10x6SfloatBlockEXT : return "Astc10x6SfloatBlockEXT";
+ case Format::eAstc10x8SfloatBlockEXT : return "Astc10x8SfloatBlockEXT";
+ case Format::eAstc10x10SfloatBlockEXT : return "Astc10x10SfloatBlockEXT";
+ case Format::eAstc12x10SfloatBlockEXT : return "Astc12x10SfloatBlockEXT";
+ case Format::eAstc12x12SfloatBlockEXT : return "Astc12x12SfloatBlockEXT";
default: return "invalid";
}
}
@@ -4108,7 +4228,8 @@
{
eUint16 = VK_INDEX_TYPE_UINT16,
eUint32 = VK_INDEX_TYPE_UINT32,
- eNoneNV = VK_INDEX_TYPE_NONE_NV
+ eNoneNV = VK_INDEX_TYPE_NONE_NV,
+ eUint8EXT = VK_INDEX_TYPE_UINT8_EXT
};
VULKAN_HPP_INLINE std::string to_string( IndexType value )
@@ -4118,6 +4239,7 @@
case IndexType::eUint16 : return "Uint16";
case IndexType::eUint32 : return "Uint32";
case IndexType::eNoneNV : return "NoneNV";
+ case IndexType::eUint8EXT : return "Uint8EXT";
default: return "invalid";
}
}
@@ -4164,6 +4286,26 @@
}
}
+ enum class LineRasterizationModeEXT
+ {
+ eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
+ eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
+ eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT,
+ eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( LineRasterizationModeEXT value )
+ {
+ switch ( value )
+ {
+ case LineRasterizationModeEXT::eDefault : return "Default";
+ case LineRasterizationModeEXT::eRectangular : return "Rectangular";
+ case LineRasterizationModeEXT::eBresenham : return "Bresenham";
+ case LineRasterizationModeEXT::eRectangularSmooth : return "RectangularSmooth";
+ default: return "invalid";
+ }
+ }
+
enum class LogicOp
{
eClear = VK_LOGIC_OP_CLEAR,
@@ -4462,6 +4604,26 @@
}
}
+ enum class PipelineExecutableStatisticFormatKHR
+ {
+ eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+ eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR,
+ eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR,
+ eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( PipelineExecutableStatisticFormatKHR value )
+ {
+ switch ( value )
+ {
+ case PipelineExecutableStatisticFormatKHR::eBool32 : return "Bool32";
+ case PipelineExecutableStatisticFormatKHR::eInt64 : return "Int64";
+ case PipelineExecutableStatisticFormatKHR::eUint64 : return "Uint64";
+ case PipelineExecutableStatisticFormatKHR::eFloat64 : return "Float64";
+ default: return "invalid";
+ }
+ }
+
enum class PointClippingBehavior
{
eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
@@ -4734,7 +4896,8 @@
eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
- eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
+ eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
+ eMirrorClampToEdgeKHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR
};
VULKAN_HPP_INLINE std::string to_string( SamplerAddressMode value )
@@ -4849,6 +5012,40 @@
}
}
+ enum class SemaphoreTypeKHR
+ {
+ eBinary = VK_SEMAPHORE_TYPE_BINARY_KHR,
+ eTimeline = VK_SEMAPHORE_TYPE_TIMELINE_KHR
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( SemaphoreTypeKHR value )
+ {
+ switch ( value )
+ {
+ case SemaphoreTypeKHR::eBinary : return "Binary";
+ case SemaphoreTypeKHR::eTimeline : return "Timeline";
+ default: return "invalid";
+ }
+ }
+
+ enum class ShaderFloatControlsIndependenceKHR
+ {
+ e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR,
+ eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR,
+ eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( ShaderFloatControlsIndependenceKHR value )
+ {
+ switch ( value )
+ {
+ case ShaderFloatControlsIndependenceKHR::e32BitOnly : return "32BitOnly";
+ case ShaderFloatControlsIndependenceKHR::eAll : return "All";
+ case ShaderFloatControlsIndependenceKHR::eNone : return "None";
+ default: return "invalid";
+ }
+ }
+
enum class ShaderInfoTypeAMD
{
eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
@@ -5101,6 +5298,7 @@
eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
+ ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
@@ -5121,7 +5319,7 @@
eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
- ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
+ ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX,
eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX,
@@ -5145,6 +5343,10 @@
ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
+ ePhysicalDeviceImagelessFramebufferFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR,
+ eFramebufferAttachmentsCreateInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR,
+ eFramebufferAttachmentImageInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR,
+ eRenderPassAttachmentBeginInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR,
eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR,
@@ -5231,11 +5433,14 @@
ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
+ ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR,
ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR,
eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
+ ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
+ ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT,
ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
@@ -5257,7 +5462,13 @@
ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV,
eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
- ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL,
+ ePhysicalDeviceTimelineSemaphoreFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR,
+ ePhysicalDeviceTimelineSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR,
+ eSemaphoreTypeCreateInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR,
+ eTimelineSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR,
+ eSemaphoreWaitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR,
+ eSemaphoreSignalInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR,
+ ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL,
eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL,
ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL,
@@ -5274,6 +5485,11 @@
ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT,
+ ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT,
+ ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
+ ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT,
+ ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
+ ePhysicalDeviceCoherentMemoryFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
@@ -5297,7 +5513,20 @@
eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT,
+ ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
+ ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
+ ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT,
+ ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
+ ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
+ ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR,
+ ePipelineExecutablePropertiesKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR,
+ ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR,
+ ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR,
+ ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
+ ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
+ ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
+ ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES,
eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
@@ -5333,6 +5562,7 @@
ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+ ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
@@ -5520,6 +5750,7 @@
case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV : return "Win32KeyedMutexAcquireReleaseInfoNV";
case StructureType::eValidationFlagsEXT : return "ValidationFlagsEXT";
case StructureType::eViSurfaceCreateInfoNN : return "ViSurfaceCreateInfoNN";
+ case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT : return "PhysicalDeviceTextureCompressionAstcHdrFeaturesEXT";
case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT";
case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT : return "PhysicalDeviceAstcDecodeFeaturesEXT";
case StructureType::eImportMemoryWin32HandleInfoKHR : return "ImportMemoryWin32HandleInfoKHR";
@@ -5540,7 +5771,7 @@
case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT";
case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT";
case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT";
- case StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR : return "PhysicalDeviceFloat16Int8FeaturesKHR";
+ case StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR : return "PhysicalDeviceShaderFloat16Int8FeaturesKHR";
case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR";
case StructureType::eObjectTableCreateInfoNVX : return "ObjectTableCreateInfoNVX";
case StructureType::eIndirectCommandsLayoutCreateInfoNVX : return "IndirectCommandsLayoutCreateInfoNVX";
@@ -5564,6 +5795,10 @@
case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT";
case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT";
case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT";
+ case StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR : return "PhysicalDeviceImagelessFramebufferFeaturesKHR";
+ case StructureType::eFramebufferAttachmentsCreateInfoKHR : return "FramebufferAttachmentsCreateInfoKHR";
+ case StructureType::eFramebufferAttachmentImageInfoKHR : return "FramebufferAttachmentImageInfoKHR";
+ case StructureType::eRenderPassAttachmentBeginInfoKHR : return "RenderPassAttachmentBeginInfoKHR";
case StructureType::eAttachmentDescription2KHR : return "AttachmentDescription2KHR";
case StructureType::eAttachmentReference2KHR : return "AttachmentReference2KHR";
case StructureType::eSubpassDescription2KHR : return "SubpassDescription2KHR";
@@ -5650,11 +5885,14 @@
case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT";
case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT";
case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT : return "DeviceQueueGlobalPriorityCreateInfoEXT";
+ case StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR : return "PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR";
case StructureType::ePhysicalDevice8BitStorageFeaturesKHR : return "PhysicalDevice8BitStorageFeaturesKHR";
case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR : return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
+ case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR";
+ case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD";
case StructureType::eCalibratedTimestampInfoEXT : return "CalibratedTimestampInfoEXT";
case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
@@ -5676,6 +5914,12 @@
case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV";
case StructureType::eCheckpointDataNV : return "CheckpointDataNV";
case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV";
+ case StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR : return "PhysicalDeviceTimelineSemaphoreFeaturesKHR";
+ case StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR : return "PhysicalDeviceTimelineSemaphorePropertiesKHR";
+ case StructureType::eSemaphoreTypeCreateInfoKHR : return "SemaphoreTypeCreateInfoKHR";
+ case StructureType::eTimelineSemaphoreSubmitInfoKHR : return "TimelineSemaphoreSubmitInfoKHR";
+ case StructureType::eSemaphoreWaitInfoKHR : return "SemaphoreWaitInfoKHR";
+ case StructureType::eSemaphoreSignalInfoKHR : return "SemaphoreSignalInfoKHR";
case StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : return "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL";
case StructureType::eQueryPoolCreateInfoINTEL : return "QueryPoolCreateInfoINTEL";
case StructureType::eInitializePerformanceApiInfoINTEL : return "InitializePerformanceApiInfoINTEL";
@@ -5693,6 +5937,11 @@
case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT";
case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT";
case StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT : return "PhysicalDeviceScalarBlockLayoutFeaturesEXT";
+ case StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT : return "PhysicalDeviceSubgroupSizeControlPropertiesEXT";
+ case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : return "PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT";
+ case StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT : return "PhysicalDeviceSubgroupSizeControlFeaturesEXT";
+ case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD";
+ case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD : return "PhysicalDeviceCoherentMemoryFeaturesAMD";
case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT";
case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT";
case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT";
@@ -5716,7 +5965,20 @@
case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT : return "SurfaceCapabilitiesFullScreenExclusiveEXT";
case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT";
case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT";
+ case StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT : return "PhysicalDeviceLineRasterizationFeaturesEXT";
+ case StructureType::ePipelineRasterizationLineStateCreateInfoEXT : return "PipelineRasterizationLineStateCreateInfoEXT";
+ case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT : return "PhysicalDeviceLineRasterizationPropertiesEXT";
case StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT : return "PhysicalDeviceHostQueryResetFeaturesEXT";
+ case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT : return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
+ case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR : return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
+ case StructureType::ePipelineInfoKHR : return "PipelineInfoKHR";
+ case StructureType::ePipelineExecutablePropertiesKHR : return "PipelineExecutablePropertiesKHR";
+ case StructureType::ePipelineExecutableInfoKHR : return "PipelineExecutableInfoKHR";
+ case StructureType::ePipelineExecutableStatisticKHR : return "PipelineExecutableStatisticKHR";
+ case StructureType::ePipelineExecutableInternalRepresentationKHR : return "PipelineExecutableInternalRepresentationKHR";
+ case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : return "PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT";
+ case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT";
+ case StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT : return "PhysicalDeviceTexelBufferAlignmentPropertiesEXT";
default: return "invalid";
}
}
@@ -5856,7 +6118,8 @@
enum class ValidationFeatureEnableEXT
{
eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
- eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT
+ eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
+ eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT
};
VULKAN_HPP_INLINE std::string to_string( ValidationFeatureEnableEXT value )
@@ -5865,6 +6128,7 @@
{
case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted";
case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot : return "GpuAssistedReserveBindingSlot";
+ case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices";
default: return "invalid";
}
}
@@ -5931,6 +6195,11 @@
}
}
+ template<ObjectType value>
+ struct cpp_type
+ {
+ };
+
enum class AccessFlagBits
{
eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
@@ -6001,16 +6270,6 @@
using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
- VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
- {
- return AccessFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
- {
- return ~( AccessFlags( bits ) );
- }
-
template <> struct FlagTraits<AccessFlagBits>
{
enum
@@ -6019,6 +6278,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags operator&( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags operator^( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AccessFlags operator~( AccessFlagBits bits )
+ {
+ return ~( AccessFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( AccessFlagBits bit0, AccessFlagBits bit1 )
+ {
+ return AccessFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( AccessFlags value )
{
if ( !value ) return "{}";
@@ -6088,16 +6377,6 @@
using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
- VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
- {
- return AttachmentDescriptionFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
- {
- return ~( AttachmentDescriptionFlags( bits ) );
- }
-
template <> struct FlagTraits<AttachmentDescriptionFlagBits>
{
enum
@@ -6106,6 +6385,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags operator&( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags operator^( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
+ {
+ return ~( AttachmentDescriptionFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
+ {
+ return AttachmentDescriptionFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value )
{
if ( !value ) return "{}";
@@ -6139,16 +6448,6 @@
using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
- VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
- {
- return BufferCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
- {
- return ~( BufferCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<BufferCreateFlagBits>
{
enum
@@ -6157,6 +6456,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator&( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator^( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferCreateFlags operator~( BufferCreateFlagBits bits )
+ {
+ return ~( BufferCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
+ {
+ return BufferCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value )
{
if ( !value ) return "{}";
@@ -6212,16 +6541,6 @@
using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
- VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
- {
- return BufferUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
- {
- return ~( BufferUsageFlags( bits ) );
- }
-
template <> struct FlagTraits<BufferUsageFlagBits>
{
enum
@@ -6230,6 +6549,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator&( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator^( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BufferUsageFlags operator~( BufferUsageFlagBits bits )
+ {
+ return ~( BufferUsageFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
+ {
+ return BufferUsageFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value )
{
if ( !value ) return "{}";
@@ -6291,16 +6640,6 @@
using BuildAccelerationStructureFlagsNV = Flags<BuildAccelerationStructureFlagBitsNV, VkBuildAccelerationStructureFlagsNV>;
- VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
- {
- return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits )
- {
- return ~( BuildAccelerationStructureFlagsNV( bits ) );
- }
-
template <> struct FlagTraits<BuildAccelerationStructureFlagBitsNV>
{
enum
@@ -6309,6 +6648,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsNV operator|( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+ {
+ return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsNV operator&( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+ {
+ return BuildAccelerationStructureFlagsNV( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsNV operator^( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+ {
+ return BuildAccelerationStructureFlagsNV( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR BuildAccelerationStructureFlagsNV operator~( BuildAccelerationStructureFlagBitsNV bits )
+ {
+ return ~( BuildAccelerationStructureFlagsNV( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+ {
+ return BuildAccelerationStructureFlagsNV( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( BuildAccelerationStructureFlagBitsNV bit0, BuildAccelerationStructureFlagBitsNV bit1 )
+ {
+ return BuildAccelerationStructureFlagsNV( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsNV value )
{
if ( !value ) return "{}";
@@ -6344,16 +6713,6 @@
using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
- VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
- {
- return ColorComponentFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
- {
- return ~( ColorComponentFlags( bits ) );
- }
-
template <> struct FlagTraits<ColorComponentFlagBits>
{
enum
@@ -6362,6 +6721,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags operator&( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags operator^( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ColorComponentFlags operator~( ColorComponentFlagBits bits )
+ {
+ return ~( ColorComponentFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
+ {
+ return ColorComponentFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value )
{
if ( !value ) return "{}";
@@ -6390,16 +6779,6 @@
using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
- VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
- {
- return CommandBufferResetFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
- {
- return ~( CommandBufferResetFlags( bits ) );
- }
-
template <> struct FlagTraits<CommandBufferResetFlagBits>
{
enum
@@ -6408,6 +6787,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags operator&( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags operator^( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
+ {
+ return ~( CommandBufferResetFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
+ {
+ return CommandBufferResetFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value )
{
if ( !value ) return "{}";
@@ -6437,16 +6846,6 @@
using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
- VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
- {
- return CommandBufferUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
- {
- return ~( CommandBufferUsageFlags( bits ) );
- }
-
template <> struct FlagTraits<CommandBufferUsageFlagBits>
{
enum
@@ -6455,6 +6854,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+ {
+ return CommandBufferUsageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags operator&( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+ {
+ return CommandBufferUsageFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags operator^( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+ {
+ return CommandBufferUsageFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
+ {
+ return ~( CommandBufferUsageFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+ {
+ return CommandBufferUsageFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
+ {
+ return CommandBufferUsageFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value )
{
if ( !value ) return "{}";
@@ -6486,16 +6915,6 @@
using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
- VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
- {
- return CommandPoolCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
- {
- return ~( CommandPoolCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<CommandPoolCreateFlagBits>
{
enum
@@ -6504,6 +6923,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags operator&( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags operator^( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
+ {
+ return ~( CommandPoolCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
+ {
+ return CommandPoolCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value )
{
if ( !value ) return "{}";
@@ -6531,16 +6980,6 @@
using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
- VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
- {
- return CommandPoolResetFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
- {
- return ~( CommandPoolResetFlags( bits ) );
- }
-
template <> struct FlagTraits<CommandPoolResetFlagBits>
{
enum
@@ -6549,6 +6988,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags operator&( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags operator^( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
+ {
+ return ~( CommandPoolResetFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
+ {
+ return CommandPoolResetFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value )
{
if ( !value ) return "{}";
@@ -6597,16 +7066,6 @@
using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
- VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
- {
- return CompositeAlphaFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
- {
- return ~( CompositeAlphaFlagsKHR( bits ) );
- }
-
template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
{
enum
@@ -6615,6 +7074,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR operator&( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR operator^( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
+ {
+ return ~( CompositeAlphaFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
+ {
+ return CompositeAlphaFlagsKHR( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value )
{
if ( !value ) return "{}";
@@ -6643,16 +7132,6 @@
using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT, VkConditionalRenderingFlagsEXT>;
- VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
- {
- return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits )
- {
- return ~( ConditionalRenderingFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT>
{
enum
@@ -6661,6 +7140,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT operator|( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
+ {
+ return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT operator&( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
+ {
+ return ConditionalRenderingFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT operator^( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
+ {
+ return ConditionalRenderingFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ConditionalRenderingFlagsEXT operator~( ConditionalRenderingFlagBitsEXT bits )
+ {
+ return ~( ConditionalRenderingFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
+ {
+ return ConditionalRenderingFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ConditionalRenderingFlagBitsEXT bit0, ConditionalRenderingFlagBitsEXT bit1 )
+ {
+ return ConditionalRenderingFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value )
{
if ( !value ) return "{}";
@@ -6692,16 +7201,6 @@
using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;
- VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
- {
- return CullModeFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits )
- {
- return ~( CullModeFlags( bits ) );
- }
-
template <> struct FlagTraits<CullModeFlagBits>
{
enum
@@ -6710,15 +7209,43 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
+ {
+ return CullModeFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags operator&( CullModeFlagBits bit0, CullModeFlagBits bit1 )
+ {
+ return CullModeFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags operator^( CullModeFlagBits bit0, CullModeFlagBits bit1 )
+ {
+ return CullModeFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR CullModeFlags operator~( CullModeFlagBits bits )
+ {
+ return ~( CullModeFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( CullModeFlagBits bit0, CullModeFlagBits bit1 )
+ {
+ return CullModeFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( CullModeFlagBits bit0, CullModeFlagBits bit1 )
+ {
+ return CullModeFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( CullModeFlags value )
{
if ( !value ) return "{}";
std::string result;
- if ( value & CullModeFlagBits::eNone ) result += "None | ";
if ( value & CullModeFlagBits::eFront ) result += "Front | ";
if ( value & CullModeFlagBits::eBack ) result += "Back | ";
- if ( value & CullModeFlagBits::eFrontAndBack ) result += "FrontAndBack | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
@@ -6746,16 +7273,6 @@
using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
- VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
- {
- return DebugReportFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
- {
- return ~( DebugReportFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<DebugReportFlagBitsEXT>
{
enum
@@ -6764,6 +7281,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+ {
+ return DebugReportFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT operator&( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+ {
+ return DebugReportFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT operator^( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+ {
+ return DebugReportFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
+ {
+ return ~( DebugReportFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+ {
+ return DebugReportFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
+ {
+ return DebugReportFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value )
{
if ( !value ) return "{}";
@@ -6799,16 +7346,6 @@
using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageSeverityFlagsEXT>;
- VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
- {
- return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits )
- {
- return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT>
{
enum
@@ -6817,6 +7354,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT operator|( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT operator&( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageSeverityFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT operator^( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageSeverityFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT operator~( DebugUtilsMessageSeverityFlagBitsEXT bits )
+ {
+ return ~( DebugUtilsMessageSeverityFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageSeverityFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DebugUtilsMessageSeverityFlagBitsEXT bit0, DebugUtilsMessageSeverityFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageSeverityFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value )
{
if ( !value ) return "{}";
@@ -6849,16 +7416,6 @@
using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT>;
- VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
- {
- return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits )
- {
- return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT>
{
enum
@@ -6867,6 +7424,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT operator|( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT operator&( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageTypeFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT operator^( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageTypeFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DebugUtilsMessageTypeFlagsEXT operator~( DebugUtilsMessageTypeFlagBitsEXT bits )
+ {
+ return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageTypeFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DebugUtilsMessageTypeFlagBitsEXT bit0, DebugUtilsMessageTypeFlagBitsEXT bit1 )
+ {
+ return DebugUtilsMessageTypeFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value )
{
if ( !value ) return "{}";
@@ -6930,16 +7517,6 @@
using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
- VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
- {
- return DependencyFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
- {
- return ~( DependencyFlags( bits ) );
- }
-
template <> struct FlagTraits<DependencyFlagBits>
{
enum
@@ -6948,6 +7525,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator&( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator^( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DependencyFlags operator~( DependencyFlagBits bits )
+ {
+ return ~( DependencyFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DependencyFlagBits bit0, DependencyFlagBits bit1 )
+ {
+ return DependencyFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DependencyFlags value )
{
if ( !value ) return "{}";
@@ -6981,16 +7588,6 @@
using DescriptorBindingFlagsEXT = Flags<DescriptorBindingFlagBitsEXT, VkDescriptorBindingFlagsEXT>;
- VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
- {
- return DescriptorBindingFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits )
- {
- return ~( DescriptorBindingFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<DescriptorBindingFlagBitsEXT>
{
enum
@@ -6999,6 +7596,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlagsEXT operator|( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+ {
+ return DescriptorBindingFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlagsEXT operator&( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+ {
+ return DescriptorBindingFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlagsEXT operator^( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+ {
+ return DescriptorBindingFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorBindingFlagsEXT operator~( DescriptorBindingFlagBitsEXT bits )
+ {
+ return ~( DescriptorBindingFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+ {
+ return DescriptorBindingFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DescriptorBindingFlagBitsEXT bit0, DescriptorBindingFlagBitsEXT bit1 )
+ {
+ return DescriptorBindingFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlagsEXT value )
{
if ( !value ) return "{}";
@@ -7029,16 +7656,6 @@
using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
- VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
- {
- return DescriptorPoolCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
- {
- return ~( DescriptorPoolCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
{
enum
@@ -7047,6 +7664,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags operator&( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags operator^( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
+ {
+ return ~( DescriptorPoolCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
+ {
+ return DescriptorPoolCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value )
{
if ( !value ) return "{}";
@@ -7090,16 +7737,6 @@
using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
- VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
- {
- return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
- {
- return ~( DescriptorSetLayoutCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
{
enum
@@ -7108,6 +7745,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+ {
+ return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags operator&( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+ {
+ return DescriptorSetLayoutCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags operator^( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+ {
+ return DescriptorSetLayoutCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
+ {
+ return ~( DescriptorSetLayoutCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+ {
+ return DescriptorSetLayoutCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
+ {
+ return DescriptorSetLayoutCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value )
{
if ( !value ) return "{}";
@@ -7172,16 +7839,6 @@
using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR, VkDeviceGroupPresentModeFlagsKHR>;
- VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
- {
- return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits )
- {
- return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
- }
-
template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR>
{
enum
@@ -7190,6 +7847,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR operator|( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
+ {
+ return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR operator&( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
+ {
+ return DeviceGroupPresentModeFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR operator^( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
+ {
+ return DeviceGroupPresentModeFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceGroupPresentModeFlagsKHR operator~( DeviceGroupPresentModeFlagBitsKHR bits )
+ {
+ return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
+ {
+ return DeviceGroupPresentModeFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DeviceGroupPresentModeFlagBitsKHR bit0, DeviceGroupPresentModeFlagBitsKHR bit1 )
+ {
+ return DeviceGroupPresentModeFlagsKHR( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value )
{
if ( !value ) return "{}";
@@ -7218,16 +7905,6 @@
using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
- VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
- {
- return DeviceQueueCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits )
- {
- return ~( DeviceQueueCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<DeviceQueueCreateFlagBits>
{
enum
@@ -7236,6 +7913,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+ {
+ return DeviceQueueCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags operator&( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+ {
+ return DeviceQueueCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags operator^( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+ {
+ return DeviceQueueCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DeviceQueueCreateFlags operator~( DeviceQueueCreateFlagBits bits )
+ {
+ return ~( DeviceQueueCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+ {
+ return DeviceQueueCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
+ {
+ return DeviceQueueCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value )
{
if ( !value ) return "{}";
@@ -7282,16 +7989,6 @@
using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
- VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
- {
- return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
- {
- return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
- }
-
template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
{
enum
@@ -7300,6 +7997,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR operator&( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR operator^( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
+ {
+ return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
+ {
+ return DisplayPlaneAlphaFlagsKHR( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value )
{
if ( !value ) return "{}";
@@ -7362,16 +8089,6 @@
using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits, VkExternalFenceFeatureFlags>;
- VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
- {
- return ExternalFenceFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits )
- {
- return ~( ExternalFenceFeatureFlags( bits ) );
- }
-
template <> struct FlagTraits<ExternalFenceFeatureFlagBits>
{
enum
@@ -7380,6 +8097,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags operator|( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+ {
+ return ExternalFenceFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags operator&( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+ {
+ return ExternalFenceFeatureFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags operator^( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+ {
+ return ExternalFenceFeatureFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceFeatureFlags operator~( ExternalFenceFeatureFlagBits bits )
+ {
+ return ~( ExternalFenceFeatureFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+ {
+ return ExternalFenceFeatureFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalFenceFeatureFlagBits bit0, ExternalFenceFeatureFlagBits bit1 )
+ {
+ return ExternalFenceFeatureFlags( bit0 ) != bit1;
+ }
+
using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value )
@@ -7418,16 +8165,6 @@
using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits, VkExternalFenceHandleTypeFlags>;
- VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
- {
- return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits )
- {
- return ~( ExternalFenceHandleTypeFlags( bits ) );
- }
-
template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits>
{
enum
@@ -7436,6 +8173,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags operator|( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+ {
+ return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags operator&( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+ {
+ return ExternalFenceHandleTypeFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags operator^( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+ {
+ return ExternalFenceHandleTypeFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalFenceHandleTypeFlags operator~( ExternalFenceHandleTypeFlagBits bits )
+ {
+ return ~( ExternalFenceHandleTypeFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+ {
+ return ExternalFenceHandleTypeFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalFenceHandleTypeFlagBits bit0, ExternalFenceHandleTypeFlagBits bit1 )
+ {
+ return ExternalFenceHandleTypeFlags( bit0 ) != bit1;
+ }
+
using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value )
@@ -7473,16 +8240,6 @@
using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits, VkExternalMemoryFeatureFlags>;
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
- {
- return ExternalMemoryFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits )
- {
- return ~( ExternalMemoryFeatureFlags( bits ) );
- }
-
template <> struct FlagTraits<ExternalMemoryFeatureFlagBits>
{
enum
@@ -7491,6 +8248,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags operator|( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ {
+ return ExternalMemoryFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags operator&( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ {
+ return ExternalMemoryFeatureFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags operator^( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ {
+ return ExternalMemoryFeatureFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlags operator~( ExternalMemoryFeatureFlagBits bits )
+ {
+ return ~( ExternalMemoryFeatureFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ {
+ return ExternalMemoryFeatureFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalMemoryFeatureFlagBits bit0, ExternalMemoryFeatureFlagBits bit1 )
+ {
+ return ExternalMemoryFeatureFlags( bit0 ) != bit1;
+ }
+
using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value )
@@ -7524,16 +8311,6 @@
using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
- {
- return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
- {
- return ~( ExternalMemoryFeatureFlagsNV( bits ) );
- }
-
template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
{
enum
@@ -7542,6 +8319,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+ {
+ return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV operator&( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+ {
+ return ExternalMemoryFeatureFlagsNV( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV operator^( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+ {
+ return ExternalMemoryFeatureFlagsNV( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
+ {
+ return ~( ExternalMemoryFeatureFlagsNV( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+ {
+ return ExternalMemoryFeatureFlagsNV( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
+ {
+ return ExternalMemoryFeatureFlagsNV( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value )
{
if ( !value ) return "{}";
@@ -7596,16 +8403,6 @@
using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits, VkExternalMemoryHandleTypeFlags>;
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
- {
- return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits )
- {
- return ~( ExternalMemoryHandleTypeFlags( bits ) );
- }
-
template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits>
{
enum
@@ -7614,6 +8411,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags operator|( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+ {
+ return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags operator&( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+ {
+ return ExternalMemoryHandleTypeFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags operator^( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+ {
+ return ExternalMemoryHandleTypeFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlags operator~( ExternalMemoryHandleTypeFlagBits bits )
+ {
+ return ~( ExternalMemoryHandleTypeFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+ {
+ return ExternalMemoryHandleTypeFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalMemoryHandleTypeFlagBits bit0, ExternalMemoryHandleTypeFlagBits bit1 )
+ {
+ return ExternalMemoryHandleTypeFlags( bit0 ) != bit1;
+ }
+
using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value )
@@ -7657,16 +8484,6 @@
using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
- {
- return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
- {
- return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
- }
-
template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
{
enum
@@ -7675,6 +8492,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV operator&( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV operator^( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
+ {
+ return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
+ {
+ return ExternalMemoryHandleTypeFlagsNV( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value )
{
if ( !value ) return "{}";
@@ -7707,16 +8554,6 @@
using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits, VkExternalSemaphoreFeatureFlags>;
- VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
- {
- return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits )
- {
- return ~( ExternalSemaphoreFeatureFlags( bits ) );
- }
-
template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits>
{
enum
@@ -7725,6 +8562,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags operator|( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+ {
+ return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags operator&( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+ {
+ return ExternalSemaphoreFeatureFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags operator^( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+ {
+ return ExternalSemaphoreFeatureFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreFeatureFlags operator~( ExternalSemaphoreFeatureFlagBits bits )
+ {
+ return ~( ExternalSemaphoreFeatureFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+ {
+ return ExternalSemaphoreFeatureFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalSemaphoreFeatureFlagBits bit0, ExternalSemaphoreFeatureFlagBits bit1 )
+ {
+ return ExternalSemaphoreFeatureFlags( bit0 ) != bit1;
+ }
+
using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value )
@@ -7766,16 +8633,6 @@
using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreHandleTypeFlags>;
- VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
- {
- return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits )
- {
- return ~( ExternalSemaphoreHandleTypeFlags( bits ) );
- }
-
template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits>
{
enum
@@ -7784,6 +8641,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags operator|( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+ {
+ return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags operator&( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+ {
+ return ExternalSemaphoreHandleTypeFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags operator^( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+ {
+ return ExternalSemaphoreHandleTypeFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ExternalSemaphoreHandleTypeFlags operator~( ExternalSemaphoreHandleTypeFlagBits bits )
+ {
+ return ~( ExternalSemaphoreHandleTypeFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+ {
+ return ExternalSemaphoreHandleTypeFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ExternalSemaphoreHandleTypeFlagBits bit0, ExternalSemaphoreHandleTypeFlagBits bit1 )
+ {
+ return ExternalSemaphoreHandleTypeFlags( bit0 ) != bit1;
+ }
+
using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value )
@@ -7815,16 +8702,6 @@
using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
- VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
- {
- return FenceCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
- {
- return ~( FenceCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<FenceCreateFlagBits>
{
enum
@@ -7833,6 +8710,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+ {
+ return FenceCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator&( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+ {
+ return FenceCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator^( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+ {
+ return FenceCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceCreateFlags operator~( FenceCreateFlagBits bits )
+ {
+ return ~( FenceCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+ {
+ return FenceCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
+ {
+ return FenceCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value )
{
if ( !value ) return "{}";
@@ -7859,16 +8766,6 @@
using FenceImportFlags = Flags<FenceImportFlagBits, VkFenceImportFlags>;
- VULKAN_HPP_INLINE FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
- {
- return FenceImportFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE FenceImportFlags operator~( FenceImportFlagBits bits )
- {
- return ~( FenceImportFlags( bits ) );
- }
-
template <> struct FlagTraits<FenceImportFlagBits>
{
enum
@@ -7877,6 +8774,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator|( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ {
+ return FenceImportFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator&( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ {
+ return FenceImportFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator^( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ {
+ return FenceImportFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FenceImportFlags operator~( FenceImportFlagBits bits )
+ {
+ return ~( FenceImportFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ {
+ return FenceImportFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( FenceImportFlagBits bit0, FenceImportFlagBits bit1 )
+ {
+ return FenceImportFlags( bit0 ) != bit1;
+ }
+
using FenceImportFlagsKHR = FenceImportFlags;
VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value )
@@ -7962,16 +8889,6 @@
using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
- VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
- {
- return FormatFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
- {
- return ~( FormatFeatureFlags( bits ) );
- }
-
template <> struct FlagTraits<FormatFeatureFlagBits>
{
enum
@@ -7980,6 +8897,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
+ {
+ return FormatFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FormatFeatureFlags operator&( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
+ {
+ return FormatFeatureFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FormatFeatureFlags operator^( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
+ {
+ return FormatFeatureFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
+ {
+ return ~( FormatFeatureFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
+ {
+ return FormatFeatureFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
+ {
+ return FormatFeatureFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value )
{
if ( !value ) return "{}";
@@ -8014,18 +8961,66 @@
}
enum class FramebufferCreateFlagBits
- {};
-
- VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits )
{
- return "(void)";
+ eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case FramebufferCreateFlagBits::eImagelessKHR : return "ImagelessKHR";
+ default: return "invalid";
+ }
}
using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
- VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags )
+ template <> struct FlagTraits<FramebufferCreateFlagBits>
{
- return "{}";
+ enum
+ {
+ allFlags = VkFlags(FramebufferCreateFlagBits::eImagelessKHR)
+ };
+ };
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags operator|( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
+ {
+ return FramebufferCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags operator&( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
+ {
+ return FramebufferCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags operator^( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
+ {
+ return FramebufferCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR FramebufferCreateFlags operator~( FramebufferCreateFlagBits bits )
+ {
+ return ~( FramebufferCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
+ {
+ return FramebufferCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
+ {
+ return FramebufferCreateFlags( bit0 ) != bit1;
+ }
+
+ VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value )
+ {
+ if ( !value ) return "{}";
+ std::string result;
+
+ if ( value & FramebufferCreateFlagBits::eImagelessKHR ) result += "ImagelessKHR | ";
+ return "{ " + result.substr(0, result.size() - 3) + " }";
}
enum class GeometryFlagBitsNV
@@ -8046,16 +9041,6 @@
using GeometryFlagsNV = Flags<GeometryFlagBitsNV, VkGeometryFlagsNV>;
- VULKAN_HPP_INLINE GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
- {
- return GeometryFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE GeometryFlagsNV operator~( GeometryFlagBitsNV bits )
- {
- return ~( GeometryFlagsNV( bits ) );
- }
-
template <> struct FlagTraits<GeometryFlagBitsNV>
{
enum
@@ -8064,6 +9049,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsNV operator|( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+ {
+ return GeometryFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsNV operator&( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+ {
+ return GeometryFlagsNV( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsNV operator^( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+ {
+ return GeometryFlagsNV( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryFlagsNV operator~( GeometryFlagBitsNV bits )
+ {
+ return ~( GeometryFlagsNV( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+ {
+ return GeometryFlagsNV( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( GeometryFlagBitsNV bit0, GeometryFlagBitsNV bit1 )
+ {
+ return GeometryFlagsNV( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( GeometryFlagsNV value )
{
if ( !value ) return "{}";
@@ -8096,16 +9111,6 @@
using GeometryInstanceFlagsNV = Flags<GeometryInstanceFlagBitsNV, VkGeometryInstanceFlagsNV>;
- VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
- {
- return GeometryInstanceFlagsNV( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits )
- {
- return ~( GeometryInstanceFlagsNV( bits ) );
- }
-
template <> struct FlagTraits<GeometryInstanceFlagBitsNV>
{
enum
@@ -8114,6 +9119,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsNV operator|( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+ {
+ return GeometryInstanceFlagsNV( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsNV operator&( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+ {
+ return GeometryInstanceFlagsNV( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsNV operator^( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+ {
+ return GeometryInstanceFlagsNV( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR GeometryInstanceFlagsNV operator~( GeometryInstanceFlagBitsNV bits )
+ {
+ return ~( GeometryInstanceFlagsNV( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+ {
+ return GeometryInstanceFlagsNV( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( GeometryInstanceFlagBitsNV bit0, GeometryInstanceFlagBitsNV bit1 )
+ {
+ return GeometryInstanceFlagsNV( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsNV value )
{
if ( !value ) return "{}";
@@ -8197,16 +9232,6 @@
using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
- VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
- {
- return ImageAspectFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
- {
- return ~( ImageAspectFlags( bits ) );
- }
-
template <> struct FlagTraits<ImageAspectFlagBits>
{
enum
@@ -8215,6 +9240,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator&( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator^( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageAspectFlags operator~( ImageAspectFlagBits bits )
+ {
+ return ~( ImageAspectFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
+ {
+ return ImageAspectFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value )
{
if ( !value ) return "{}";
@@ -8284,16 +9339,6 @@
using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
- VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
- {
- return ImageCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
- {
- return ~( ImageCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<ImageCreateFlagBits>
{
enum
@@ -8302,6 +9347,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+ {
+ return ImageCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageCreateFlags operator&( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+ {
+ return ImageCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageCreateFlags operator^( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+ {
+ return ImageCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageCreateFlags operator~( ImageCreateFlagBits bits )
+ {
+ return ~( ImageCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+ {
+ return ImageCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
+ {
+ return ImageCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value )
{
if ( !value ) return "{}";
@@ -8376,16 +9451,6 @@
using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
- VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
- {
- return ImageUsageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
- {
- return ~( ImageUsageFlags( bits ) );
- }
-
template <> struct FlagTraits<ImageUsageFlagBits>
{
enum
@@ -8394,6 +9459,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
+ {
+ return ImageUsageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageUsageFlags operator&( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
+ {
+ return ImageUsageFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageUsageFlags operator^( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
+ {
+ return ImageUsageFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageUsageFlags operator~( ImageUsageFlagBits bits )
+ {
+ return ~( ImageUsageFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
+ {
+ return ImageUsageFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
+ {
+ return ImageUsageFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value )
{
if ( !value ) return "{}";
@@ -8428,16 +9523,6 @@
using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
- VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
- {
- return ImageViewCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ImageViewCreateFlags operator~( ImageViewCreateFlagBits bits )
- {
- return ~( ImageViewCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<ImageViewCreateFlagBits>
{
enum
@@ -8446,6 +9531,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
+ {
+ return ImageViewCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags operator&( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
+ {
+ return ImageViewCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags operator^( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
+ {
+ return ImageViewCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ImageViewCreateFlags operator~( ImageViewCreateFlagBits bits )
+ {
+ return ~( ImageViewCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
+ {
+ return ImageViewCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
+ {
+ return ImageViewCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value )
{
if ( !value ) return "{}";
@@ -8477,16 +9592,6 @@
using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
- VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
- {
- return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
- {
- return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
- }
-
template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
{
enum
@@ -8495,6 +9600,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNVX operator&( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNVX operator^( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
+ {
+ return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
+ {
+ return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNVX value )
{
if ( !value ) return "{}";
@@ -8556,16 +9691,6 @@
using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits, VkMemoryAllocateFlags>;
- VULKAN_HPP_INLINE MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
- {
- return MemoryAllocateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits )
- {
- return ~( MemoryAllocateFlags( bits ) );
- }
-
template <> struct FlagTraits<MemoryAllocateFlagBits>
{
enum
@@ -8574,6 +9699,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags operator|( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+ {
+ return MemoryAllocateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags operator&( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+ {
+ return MemoryAllocateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags operator^( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+ {
+ return MemoryAllocateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryAllocateFlags operator~( MemoryAllocateFlagBits bits )
+ {
+ return ~( MemoryAllocateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+ {
+ return MemoryAllocateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( MemoryAllocateFlagBits bit0, MemoryAllocateFlagBits bit1 )
+ {
+ return MemoryAllocateFlags( bit0 ) != bit1;
+ }
+
using MemoryAllocateFlagsKHR = MemoryAllocateFlags;
VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value )
@@ -8604,16 +9759,6 @@
using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
- VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
- {
- return MemoryHeapFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
- {
- return ~( MemoryHeapFlags( bits ) );
- }
-
template <> struct FlagTraits<MemoryHeapFlagBits>
{
enum
@@ -8622,6 +9767,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryHeapFlags operator&( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryHeapFlags operator^( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
+ {
+ return ~( MemoryHeapFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
+ {
+ return MemoryHeapFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value )
{
if ( !value ) return "{}";
@@ -8654,7 +9829,9 @@
eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT,
- eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT
+ eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT,
+ eDeviceCoherentAMD = VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD,
+ eDeviceUncachedAMD = VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
};
VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlagBits value )
@@ -8667,30 +9844,52 @@
case MemoryPropertyFlagBits::eHostCached : return "HostCached";
case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated";
case MemoryPropertyFlagBits::eProtected : return "Protected";
+ case MemoryPropertyFlagBits::eDeviceCoherentAMD : return "DeviceCoherentAMD";
+ case MemoryPropertyFlagBits::eDeviceUncachedAMD : return "DeviceUncachedAMD";
default: return "invalid";
}
}
using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
- VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
- {
- return MemoryPropertyFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
- {
- return ~( MemoryPropertyFlags( bits ) );
- }
-
template <> struct FlagTraits<MemoryPropertyFlagBits>
{
enum
{
- allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected)
+ allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) | VkFlags(MemoryPropertyFlagBits::eProtected) | VkFlags(MemoryPropertyFlagBits::eDeviceCoherentAMD) | VkFlags(MemoryPropertyFlagBits::eDeviceUncachedAMD)
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+ {
+ return MemoryPropertyFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryPropertyFlags operator&( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+ {
+ return MemoryPropertyFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryPropertyFlags operator^( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+ {
+ return MemoryPropertyFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
+ {
+ return ~( MemoryPropertyFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+ {
+ return MemoryPropertyFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
+ {
+ return MemoryPropertyFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value )
{
if ( !value ) return "{}";
@@ -8702,6 +9901,8 @@
if ( value & MemoryPropertyFlagBits::eHostCached ) result += "HostCached | ";
if ( value & MemoryPropertyFlagBits::eLazilyAllocated ) result += "LazilyAllocated | ";
if ( value & MemoryPropertyFlagBits::eProtected ) result += "Protected | ";
+ if ( value & MemoryPropertyFlagBits::eDeviceCoherentAMD ) result += "DeviceCoherentAMD | ";
+ if ( value & MemoryPropertyFlagBits::eDeviceUncachedAMD ) result += "DeviceUncachedAMD | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
@@ -8740,16 +9941,6 @@
using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
- VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
- {
- return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
- {
- return ~( ObjectEntryUsageFlagsNVX( bits ) );
- }
-
template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
{
enum
@@ -8758,6 +9949,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ObjectEntryUsageFlagsNVX operator&( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ObjectEntryUsageFlagsNVX operator^( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
+ {
+ return ~( ObjectEntryUsageFlagsNVX( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
+ {
+ return ObjectEntryUsageFlagsNVX( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ObjectEntryUsageFlagsNVX value )
{
if ( !value ) return "{}";
@@ -8794,16 +10015,6 @@
using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits, VkPeerMemoryFeatureFlags>;
- VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
- {
- return PeerMemoryFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits )
- {
- return ~( PeerMemoryFeatureFlags( bits ) );
- }
-
template <> struct FlagTraits<PeerMemoryFeatureFlagBits>
{
enum
@@ -8812,6 +10023,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags operator|( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+ {
+ return PeerMemoryFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags operator&( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+ {
+ return PeerMemoryFeatureFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags operator^( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+ {
+ return PeerMemoryFeatureFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PeerMemoryFeatureFlags operator~( PeerMemoryFeatureFlagBits bits )
+ {
+ return ~( PeerMemoryFeatureFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+ {
+ return PeerMemoryFeatureFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PeerMemoryFeatureFlagBits bit0, PeerMemoryFeatureFlagBits bit1 )
+ {
+ return PeerMemoryFeatureFlags( bit0 ) != bit1;
+ }
+
using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value )
@@ -8856,6 +10097,21 @@
return "{}";
}
+ enum class PipelineCompilerControlFlagBitsAMD
+ {};
+
+ VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagBitsAMD )
+ {
+ return "(void)";
+ }
+
+ using PipelineCompilerControlFlagsAMD = Flags<PipelineCompilerControlFlagBitsAMD, VkPipelineCompilerControlFlagsAMD>;
+
+ VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagsAMD )
+ {
+ return "{}";
+ }
+
enum class PipelineCoverageModulationStateCreateFlagBitsNV
{};
@@ -8909,6 +10165,8 @@
eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE,
eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV,
+ eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR,
+ eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR,
eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR,
eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_KHR
};
@@ -8923,30 +10181,52 @@
case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex";
case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase";
case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV";
+ case PipelineCreateFlagBits::eCaptureStatisticsKHR : return "CaptureStatisticsKHR";
+ case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR";
default: return "invalid";
}
}
using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
- VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
- {
- return PipelineCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
- {
- return ~( PipelineCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<PipelineCreateFlagBits>
{
enum
{
- allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV)
+ allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndex) | VkFlags(PipelineCreateFlagBits::eDispatchBase) | VkFlags(PipelineCreateFlagBits::eDeferCompileNV) | VkFlags(PipelineCreateFlagBits::eCaptureStatisticsKHR) | VkFlags(PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR)
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags operator&( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags operator^( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
+ {
+ return ~( PipelineCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
+ {
+ return PipelineCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value )
{
if ( !value ) return "{}";
@@ -8958,6 +10238,8 @@
if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) result += "ViewIndexFromDeviceIndex | ";
if ( value & PipelineCreateFlagBits::eDispatchBase ) result += "DispatchBase | ";
if ( value & PipelineCreateFlagBits::eDeferCompileNV ) result += "DeferCompileNV | ";
+ if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR ) result += "CaptureStatisticsKHR | ";
+ if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR ) result += "CaptureInternalRepresentationsKHR | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
@@ -8981,16 +10263,6 @@
using PipelineCreationFeedbackFlagsEXT = Flags<PipelineCreationFeedbackFlagBitsEXT, VkPipelineCreationFeedbackFlagsEXT>;
- VULKAN_HPP_INLINE PipelineCreationFeedbackFlagsEXT operator|( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 )
- {
- return PipelineCreationFeedbackFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PipelineCreationFeedbackFlagsEXT operator~( PipelineCreationFeedbackFlagBitsEXT bits )
- {
- return ~( PipelineCreationFeedbackFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<PipelineCreationFeedbackFlagBitsEXT>
{
enum
@@ -8999,6 +10271,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT operator|( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 )
+ {
+ return PipelineCreationFeedbackFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT operator&( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 )
+ {
+ return PipelineCreationFeedbackFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT operator^( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 )
+ {
+ return PipelineCreationFeedbackFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackFlagsEXT operator~( PipelineCreationFeedbackFlagBitsEXT bits )
+ {
+ return ~( PipelineCreationFeedbackFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 )
+ {
+ return PipelineCreationFeedbackFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PipelineCreationFeedbackFlagBitsEXT bit0, PipelineCreationFeedbackFlagBitsEXT bit1 )
+ {
+ return PipelineCreationFeedbackFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagsEXT value )
{
if ( !value ) return "{}";
@@ -9161,18 +10463,69 @@
}
enum class PipelineShaderStageCreateFlagBits
- {};
-
- VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits )
{
- return "(void)";
+ eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT,
+ eRequireFullSubgroupsEXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlagBits value )
+ {
+ switch ( value )
+ {
+ case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT : return "AllowVaryingSubgroupSizeEXT";
+ case PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT : return "RequireFullSubgroupsEXT";
+ default: return "invalid";
+ }
}
using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
- VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags )
+ template <> struct FlagTraits<PipelineShaderStageCreateFlagBits>
{
- return "{}";
+ enum
+ {
+ allFlags = VkFlags(PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT) | VkFlags(PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT)
+ };
+ };
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags operator|( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
+ {
+ return PipelineShaderStageCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags operator&( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
+ {
+ return PipelineShaderStageCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags operator^( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
+ {
+ return PipelineShaderStageCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateFlags operator~( PipelineShaderStageCreateFlagBits bits )
+ {
+ return ~( PipelineShaderStageCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
+ {
+ return PipelineShaderStageCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
+ {
+ return PipelineShaderStageCreateFlags( bit0 ) != bit1;
+ }
+
+ VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value )
+ {
+ if ( !value ) return "{}";
+ std::string result;
+
+ if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSizeEXT ) result += "AllowVaryingSubgroupSizeEXT | ";
+ if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroupsEXT ) result += "RequireFullSubgroupsEXT | ";
+ return "{ " + result.substr(0, result.size() - 3) + " }";
}
enum class PipelineStageFlagBits
@@ -9241,16 +10594,6 @@
using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
- VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
- {
- return PipelineStageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
- {
- return ~( PipelineStageFlags( bits ) );
- }
-
template <> struct FlagTraits<PipelineStageFlagBits>
{
enum
@@ -9259,6 +10602,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineStageFlags operator&( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineStageFlags operator^( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PipelineStageFlags operator~( PipelineStageFlagBits bits )
+ {
+ return ~( PipelineStageFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
+ {
+ return PipelineStageFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value )
{
if ( !value ) return "{}";
@@ -9369,16 +10742,6 @@
using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
- VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
- {
- return QueryControlFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
- {
- return ~( QueryControlFlags( bits ) );
- }
-
template <> struct FlagTraits<QueryControlFlagBits>
{
enum
@@ -9387,6 +10750,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+ {
+ return QueryControlFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator&( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+ {
+ return QueryControlFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator^( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+ {
+ return QueryControlFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryControlFlags operator~( QueryControlFlagBits bits )
+ {
+ return ~( QueryControlFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+ {
+ return QueryControlFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
+ {
+ return QueryControlFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value )
{
if ( !value ) return "{}";
@@ -9432,16 +10825,6 @@
using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
- VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
- {
- return QueryPipelineStatisticFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
- {
- return ~( QueryPipelineStatisticFlags( bits ) );
- }
-
template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
{
enum
@@ -9450,6 +10833,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+ {
+ return QueryPipelineStatisticFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags operator&( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+ {
+ return QueryPipelineStatisticFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags operator^( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+ {
+ return QueryPipelineStatisticFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
+ {
+ return ~( QueryPipelineStatisticFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+ {
+ return QueryPipelineStatisticFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
+ {
+ return QueryPipelineStatisticFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value )
{
if ( !value ) return "{}";
@@ -9506,16 +10919,6 @@
using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
- VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
- {
- return QueryResultFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
- {
- return ~( QueryResultFlags( bits ) );
- }
-
template <> struct FlagTraits<QueryResultFlagBits>
{
enum
@@ -9524,6 +10927,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
+ {
+ return QueryResultFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator&( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
+ {
+ return QueryResultFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator^( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
+ {
+ return QueryResultFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueryResultFlags operator~( QueryResultFlagBits bits )
+ {
+ return ~( QueryResultFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
+ {
+ return QueryResultFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
+ {
+ return QueryResultFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value )
{
if ( !value ) return "{}";
@@ -9560,16 +10993,6 @@
using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
- VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
- {
- return QueueFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
- {
- return ~( QueueFlags( bits ) );
- }
-
template <> struct FlagTraits<QueueFlagBits>
{
enum
@@ -9578,6 +11001,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
+ {
+ return QueueFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags operator&( QueueFlagBits bit0, QueueFlagBits bit1 )
+ {
+ return QueueFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags operator^( QueueFlagBits bit0, QueueFlagBits bit1 )
+ {
+ return QueueFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR QueueFlags operator~( QueueFlagBits bits )
+ {
+ return ~( QueueFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( QueueFlagBits bit0, QueueFlagBits bit1 )
+ {
+ return QueueFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( QueueFlagBits bit0, QueueFlagBits bit1 )
+ {
+ return QueueFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( QueueFlags value )
{
if ( !value ) return "{}";
@@ -9630,16 +11083,6 @@
using ResolveModeFlagsKHR = Flags<ResolveModeFlagBitsKHR, VkResolveModeFlagsKHR>;
- VULKAN_HPP_INLINE ResolveModeFlagsKHR operator|( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
- {
- return ResolveModeFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ResolveModeFlagsKHR operator~( ResolveModeFlagBitsKHR bits )
- {
- return ~( ResolveModeFlagsKHR( bits ) );
- }
-
template <> struct FlagTraits<ResolveModeFlagBitsKHR>
{
enum
@@ -9648,12 +11091,41 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlagsKHR operator|( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
+ {
+ return ResolveModeFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlagsKHR operator&( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
+ {
+ return ResolveModeFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlagsKHR operator^( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
+ {
+ return ResolveModeFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ResolveModeFlagsKHR operator~( ResolveModeFlagBitsKHR bits )
+ {
+ return ~( ResolveModeFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
+ {
+ return ResolveModeFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ResolveModeFlagBitsKHR bit0, ResolveModeFlagBitsKHR bit1 )
+ {
+ return ResolveModeFlagsKHR( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ResolveModeFlagsKHR value )
{
if ( !value ) return "{}";
std::string result;
- if ( value & ResolveModeFlagBitsKHR::eNone ) result += "None | ";
if ( value & ResolveModeFlagBitsKHR::eSampleZero ) result += "SampleZero | ";
if ( value & ResolveModeFlagBitsKHR::eAverage ) result += "Average | ";
if ( value & ResolveModeFlagBitsKHR::eMin ) result += "Min | ";
@@ -9689,16 +11161,6 @@
using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
- VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
- {
- return SampleCountFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
- {
- return ~( SampleCountFlags( bits ) );
- }
-
template <> struct FlagTraits<SampleCountFlagBits>
{
enum
@@ -9707,6 +11169,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator&( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator^( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SampleCountFlags operator~( SampleCountFlagBits bits )
+ {
+ return ~( SampleCountFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
+ {
+ return SampleCountFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value )
{
if ( !value ) return "{}";
@@ -9740,16 +11232,6 @@
using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
- VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
- {
- return SamplerCreateFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SamplerCreateFlags operator~( SamplerCreateFlagBits bits )
- {
- return ~( SamplerCreateFlags( bits ) );
- }
-
template <> struct FlagTraits<SamplerCreateFlagBits>
{
enum
@@ -9758,6 +11240,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
+ {
+ return SamplerCreateFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags operator&( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
+ {
+ return SamplerCreateFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags operator^( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
+ {
+ return SamplerCreateFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SamplerCreateFlags operator~( SamplerCreateFlagBits bits )
+ {
+ return ~( SamplerCreateFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
+ {
+ return SamplerCreateFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
+ {
+ return SamplerCreateFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value )
{
if ( !value ) return "{}";
@@ -9800,16 +11312,6 @@
using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits, VkSemaphoreImportFlags>;
- VULKAN_HPP_INLINE SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
- {
- return SemaphoreImportFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits )
- {
- return ~( SemaphoreImportFlags( bits ) );
- }
-
template <> struct FlagTraits<SemaphoreImportFlagBits>
{
enum
@@ -9818,6 +11320,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags operator|( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
+ {
+ return SemaphoreImportFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags operator&( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
+ {
+ return SemaphoreImportFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags operator^( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
+ {
+ return SemaphoreImportFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreImportFlags operator~( SemaphoreImportFlagBits bits )
+ {
+ return ~( SemaphoreImportFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
+ {
+ return SemaphoreImportFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SemaphoreImportFlagBits bit0, SemaphoreImportFlagBits bit1 )
+ {
+ return SemaphoreImportFlags( bit0 ) != bit1;
+ }
+
using SemaphoreImportFlagsKHR = SemaphoreImportFlags;
VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value )
@@ -9829,6 +11361,84 @@
return "{ " + result.substr(0, result.size() - 3) + " }";
}
+ enum class SemaphoreWaitFlagBitsKHR
+ {
+ eAny = VK_SEMAPHORE_WAIT_ANY_BIT_KHR
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlagBitsKHR value )
+ {
+ switch ( value )
+ {
+ case SemaphoreWaitFlagBitsKHR::eAny : return "Any";
+ default: return "invalid";
+ }
+ }
+
+ using SemaphoreWaitFlagsKHR = Flags<SemaphoreWaitFlagBitsKHR, VkSemaphoreWaitFlagsKHR>;
+
+ template <> struct FlagTraits<SemaphoreWaitFlagBitsKHR>
+ {
+ enum
+ {
+ allFlags = VkFlags(SemaphoreWaitFlagBitsKHR::eAny)
+ };
+ };
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlagsKHR operator|( SemaphoreWaitFlagBitsKHR bit0, SemaphoreWaitFlagBitsKHR bit1 )
+ {
+ return SemaphoreWaitFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlagsKHR operator&( SemaphoreWaitFlagBitsKHR bit0, SemaphoreWaitFlagBitsKHR bit1 )
+ {
+ return SemaphoreWaitFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlagsKHR operator^( SemaphoreWaitFlagBitsKHR bit0, SemaphoreWaitFlagBitsKHR bit1 )
+ {
+ return SemaphoreWaitFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SemaphoreWaitFlagsKHR operator~( SemaphoreWaitFlagBitsKHR bits )
+ {
+ return ~( SemaphoreWaitFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SemaphoreWaitFlagBitsKHR bit0, SemaphoreWaitFlagBitsKHR bit1 )
+ {
+ return SemaphoreWaitFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SemaphoreWaitFlagBitsKHR bit0, SemaphoreWaitFlagBitsKHR bit1 )
+ {
+ return SemaphoreWaitFlagsKHR( bit0 ) != bit1;
+ }
+
+ VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlagsKHR value )
+ {
+ if ( !value ) return "{}";
+ std::string result;
+
+ if ( value & SemaphoreWaitFlagBitsKHR::eAny ) result += "Any | ";
+ return "{ " + result.substr(0, result.size() - 3) + " }";
+ }
+
+ enum class ShaderCorePropertiesFlagBitsAMD
+ {};
+
+ VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagBitsAMD )
+ {
+ return "(void)";
+ }
+
+ using ShaderCorePropertiesFlagsAMD = Flags<ShaderCorePropertiesFlagBitsAMD, VkShaderCorePropertiesFlagsAMD>;
+
+ VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagsAMD )
+ {
+ return "{}";
+ }
+
enum class ShaderModuleCreateFlagBits
{};
@@ -9890,16 +11500,6 @@
using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
- VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
- {
- return ShaderStageFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
- {
- return ~( ShaderStageFlags( bits ) );
- }
-
template <> struct FlagTraits<ShaderStageFlagBits>
{
enum
@@ -9908,6 +11508,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+ {
+ return ShaderStageFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator&( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+ {
+ return ShaderStageFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator^( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+ {
+ return ShaderStageFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR ShaderStageFlags operator~( ShaderStageFlagBits bits )
+ {
+ return ~( ShaderStageFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+ {
+ return ShaderStageFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
+ {
+ return ShaderStageFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value )
{
if ( !value ) return "{}";
@@ -9919,8 +11549,6 @@
if ( value & ShaderStageFlagBits::eGeometry ) result += "Geometry | ";
if ( value & ShaderStageFlagBits::eFragment ) result += "Fragment | ";
if ( value & ShaderStageFlagBits::eCompute ) result += "Compute | ";
- if ( value & ShaderStageFlagBits::eAllGraphics ) result += "AllGraphics | ";
- if ( value & ShaderStageFlagBits::eAll ) result += "All | ";
if ( value & ShaderStageFlagBits::eRaygenNV ) result += "RaygenNV | ";
if ( value & ShaderStageFlagBits::eAnyHitNV ) result += "AnyHitNV | ";
if ( value & ShaderStageFlagBits::eClosestHitNV ) result += "ClosestHitNV | ";
@@ -9952,16 +11580,6 @@
using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
- VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
- {
- return SparseImageFormatFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
- {
- return ~( SparseImageFormatFlags( bits ) );
- }
-
template <> struct FlagTraits<SparseImageFormatFlagBits>
{
enum
@@ -9970,6 +11588,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags operator&( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags operator^( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
+ {
+ return ~( SparseImageFormatFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
+ {
+ return SparseImageFormatFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value )
{
if ( !value ) return "{}";
@@ -9997,16 +11645,6 @@
using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
- VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
- {
- return SparseMemoryBindFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
- {
- return ~( SparseMemoryBindFlags( bits ) );
- }
-
template <> struct FlagTraits<SparseMemoryBindFlagBits>
{
enum
@@ -10015,6 +11653,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags operator&( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags operator^( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
+ {
+ return ~( SparseMemoryBindFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
+ {
+ return SparseMemoryBindFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value )
{
if ( !value ) return "{}";
@@ -10028,6 +11696,7 @@
{
eFront = VK_STENCIL_FACE_FRONT_BIT,
eBack = VK_STENCIL_FACE_BACK_BIT,
+ eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK,
eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
};
@@ -10037,31 +11706,51 @@
{
case StencilFaceFlagBits::eFront : return "Front";
case StencilFaceFlagBits::eBack : return "Back";
- case StencilFaceFlagBits::eVkStencilFrontAndBack : return "VkStencilFrontAndBack";
+ case StencilFaceFlagBits::eFrontAndBack : return "FrontAndBack";
default: return "invalid";
}
}
using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
- VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
- {
- return StencilFaceFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
- {
- return ~( StencilFaceFlags( bits ) );
- }
-
template <> struct FlagTraits<StencilFaceFlagBits>
{
enum
{
- allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
+ allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eFrontAndBack)
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator&( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator^( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR StencilFaceFlags operator~( StencilFaceFlagBits bits )
+ {
+ return ~( StencilFaceFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
+ {
+ return StencilFaceFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value )
{
if ( !value ) return "{}";
@@ -10069,7 +11758,6 @@
if ( value & StencilFaceFlagBits::eFront ) result += "Front | ";
if ( value & StencilFaceFlagBits::eBack ) result += "Back | ";
- if ( value & StencilFaceFlagBits::eVkStencilFrontAndBack ) result += "VkStencilFrontAndBack | ";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
@@ -10122,16 +11810,6 @@
using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits, VkSubgroupFeatureFlags>;
- VULKAN_HPP_INLINE SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
- {
- return SubgroupFeatureFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits )
- {
- return ~( SubgroupFeatureFlags( bits ) );
- }
-
template <> struct FlagTraits<SubgroupFeatureFlagBits>
{
enum
@@ -10140,6 +11818,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags operator|( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+ {
+ return SubgroupFeatureFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags operator&( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+ {
+ return SubgroupFeatureFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags operator^( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+ {
+ return SubgroupFeatureFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubgroupFeatureFlags operator~( SubgroupFeatureFlagBits bits )
+ {
+ return ~( SubgroupFeatureFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+ {
+ return SubgroupFeatureFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SubgroupFeatureFlagBits bit0, SubgroupFeatureFlagBits bit1 )
+ {
+ return SubgroupFeatureFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value )
{
if ( !value ) return "{}";
@@ -10175,16 +11883,6 @@
using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
- VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
- {
- return SubpassDescriptionFlags( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
- {
- return ~( SubpassDescriptionFlags( bits ) );
- }
-
template <> struct FlagTraits<SubpassDescriptionFlagBits>
{
enum
@@ -10193,6 +11891,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
+ {
+ return SubpassDescriptionFlags( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags operator&( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
+ {
+ return SubpassDescriptionFlags( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags operator^( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
+ {
+ return SubpassDescriptionFlags( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
+ {
+ return ~( SubpassDescriptionFlags( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
+ {
+ return SubpassDescriptionFlags( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
+ {
+ return SubpassDescriptionFlags( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value )
{
if ( !value ) return "{}";
@@ -10219,16 +11947,6 @@
using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
- VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
- {
- return SurfaceCounterFlagsEXT( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
- {
- return ~( SurfaceCounterFlagsEXT( bits ) );
- }
-
template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
{
enum
@@ -10237,6 +11955,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
+ {
+ return SurfaceCounterFlagsEXT( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT operator&( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
+ {
+ return SurfaceCounterFlagsEXT( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT operator^( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
+ {
+ return SurfaceCounterFlagsEXT( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
+ {
+ return ~( SurfaceCounterFlagsEXT( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
+ {
+ return SurfaceCounterFlagsEXT( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
+ {
+ return SurfaceCounterFlagsEXT( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value )
{
if ( !value ) return "{}";
@@ -10278,16 +12026,6 @@
using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
- VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
- {
- return SurfaceTransformFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
- {
- return ~( SurfaceTransformFlagsKHR( bits ) );
- }
-
template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
{
enum
@@ -10296,6 +12034,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR operator&( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR operator^( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
+ {
+ return ~( SurfaceTransformFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
+ {
+ return SurfaceTransformFlagsKHR( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value )
{
if ( !value ) return "{}";
@@ -10333,16 +12101,6 @@
using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
- VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
- {
- return SwapchainCreateFlagsKHR( bit0 ) | bit1;
- }
-
- VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
- {
- return ~( SwapchainCreateFlagsKHR( bits ) );
- }
-
template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
{
enum
@@ -10351,6 +12109,36 @@
};
};
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ {
+ return SwapchainCreateFlagsKHR( bit0 ) | bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR operator&( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ {
+ return SwapchainCreateFlagsKHR( bit0 ) & bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR operator^( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ {
+ return SwapchainCreateFlagsKHR( bit0 ) ^ bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
+ {
+ return ~( SwapchainCreateFlagsKHR( bits ) );
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ {
+ return SwapchainCreateFlagsKHR( bit0 ) == bit1;
+ }
+
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
+ {
+ return SwapchainCreateFlagsKHR( bit0 ) != bit1;
+ }
+
VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value )
{
if ( !value ) return "{}";
@@ -10769,7 +12557,6 @@
: SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
};
-
VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
{
switch ( result )
@@ -11117,6 +12904,8 @@
struct FormatProperties;
struct FormatProperties2;
using FormatProperties2KHR = FormatProperties2;
+ struct FramebufferAttachmentImageInfoKHR;
+ struct FramebufferAttachmentsCreateInfoKHR;
struct FramebufferCreateInfo;
struct FramebufferMixedSamplesCombinationNV;
struct GeometryAABBNV;
@@ -11245,6 +13034,7 @@
struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
+ struct PhysicalDeviceCoherentMemoryFeaturesAMD;
struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
struct PhysicalDeviceConditionalRenderingFeaturesEXT;
struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
@@ -11272,7 +13062,6 @@
struct PhysicalDeviceFeatures;
struct PhysicalDeviceFeatures2;
using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
- struct PhysicalDeviceFloat16Int8FeaturesKHR;
struct PhysicalDeviceFloatControlsPropertiesKHR;
struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
@@ -11287,9 +13076,13 @@
struct PhysicalDeviceImageFormatInfo2;
using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
struct PhysicalDeviceImageViewImageFormatInfoEXT;
+ struct PhysicalDeviceImagelessFramebufferFeaturesKHR;
+ struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
struct PhysicalDeviceLimits;
+ struct PhysicalDeviceLineRasterizationFeaturesEXT;
+ struct PhysicalDeviceLineRasterizationPropertiesEXT;
struct PhysicalDeviceMaintenance3Properties;
using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
struct PhysicalDeviceMemoryBudgetPropertiesEXT;
@@ -11305,6 +13098,7 @@
struct PhysicalDeviceMultiviewProperties;
using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
struct PhysicalDevicePCIBusInfoPropertiesEXT;
+ struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
struct PhysicalDevicePointClippingProperties;
using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
struct PhysicalDeviceProperties;
@@ -11321,20 +13115,33 @@
using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
struct PhysicalDeviceScalarBlockLayoutFeaturesEXT;
struct PhysicalDeviceShaderAtomicInt64FeaturesKHR;
+ struct PhysicalDeviceShaderClockFeaturesKHR;
+ struct PhysicalDeviceShaderCoreProperties2AMD;
struct PhysicalDeviceShaderCorePropertiesAMD;
+ struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
struct PhysicalDeviceShaderDrawParametersFeatures;
using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
+ struct PhysicalDeviceShaderFloat16Int8FeaturesKHR;
+ using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8FeaturesKHR;
struct PhysicalDeviceShaderImageFootprintFeaturesNV;
- struct PhysicalDeviceShaderIntegerFunctions2INTEL;
+ struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
+ struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
struct PhysicalDeviceShadingRateImageFeaturesNV;
struct PhysicalDeviceShadingRateImagePropertiesNV;
struct PhysicalDeviceSparseImageFormatInfo2;
using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
struct PhysicalDeviceSparseProperties;
struct PhysicalDeviceSubgroupProperties;
+ struct PhysicalDeviceSubgroupSizeControlFeaturesEXT;
+ struct PhysicalDeviceSubgroupSizeControlPropertiesEXT;
struct PhysicalDeviceSurfaceInfo2KHR;
+ struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+ struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+ struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+ struct PhysicalDeviceTimelineSemaphoreFeaturesKHR;
+ struct PhysicalDeviceTimelineSemaphorePropertiesKHR;
struct PhysicalDeviceTransformFeedbackFeaturesEXT;
struct PhysicalDeviceTransformFeedbackPropertiesEXT;
struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
@@ -11350,6 +13157,7 @@
struct PipelineColorBlendAdvancedStateCreateInfoEXT;
struct PipelineColorBlendAttachmentState;
struct PipelineColorBlendStateCreateInfo;
+ struct PipelineCompilerControlCreateInfoAMD;
struct PipelineCoverageModulationStateCreateInfoNV;
struct PipelineCoverageReductionStateCreateInfoNV;
struct PipelineCoverageToColorStateCreateInfoNV;
@@ -11358,17 +13166,25 @@
struct PipelineDepthStencilStateCreateInfo;
struct PipelineDiscardRectangleStateCreateInfoEXT;
struct PipelineDynamicStateCreateInfo;
+ struct PipelineExecutableInfoKHR;
+ struct PipelineExecutableInternalRepresentationKHR;
+ struct PipelineExecutablePropertiesKHR;
+ struct PipelineExecutableStatisticKHR;
+ union PipelineExecutableStatisticValueKHR;
+ struct PipelineInfoKHR;
struct PipelineInputAssemblyStateCreateInfo;
struct PipelineLayoutCreateInfo;
struct PipelineMultisampleStateCreateInfo;
struct PipelineRasterizationConservativeStateCreateInfoEXT;
struct PipelineRasterizationDepthClipStateCreateInfoEXT;
+ struct PipelineRasterizationLineStateCreateInfoEXT;
struct PipelineRasterizationStateCreateInfo;
struct PipelineRasterizationStateRasterizationOrderAMD;
struct PipelineRasterizationStateStreamCreateInfoEXT;
struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
struct PipelineSampleLocationsStateCreateInfoEXT;
struct PipelineShaderStageCreateInfo;
+ struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
struct PipelineTessellationDomainOriginStateCreateInfo;
using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
struct PipelineTessellationStateCreateInfo;
@@ -11401,6 +13217,7 @@
struct Rect2D;
struct RectLayerKHR;
struct RefreshCycleDurationGOOGLE;
+ struct RenderPassAttachmentBeginInfoKHR;
struct RenderPassBeginInfo;
struct RenderPassCreateInfo;
struct RenderPassCreateInfo2KHR;
@@ -11425,6 +13242,9 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
struct SemaphoreGetWin32HandleInfoKHR;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ struct SemaphoreSignalInfoKHR;
+ struct SemaphoreTypeCreateInfoKHR;
+ struct SemaphoreWaitInfoKHR;
struct ShaderModuleCreateInfo;
struct ShaderModuleValidationCacheCreateInfoEXT;
struct ShaderResourceUsageAMD;
@@ -11477,6 +13297,7 @@
struct SwapchainCreateInfoKHR;
struct SwapchainDisplayNativeHdrCreateInfoAMD;
struct TextureLODGatherFormatPropertiesAMD;
+ struct TimelineSemaphoreSubmitInfoKHR;
struct ValidationCacheCreateInfoEXT;
struct ValidationFeaturesEXT;
struct ValidationFlagsEXT;
@@ -11515,6 +13336,11 @@
class SurfaceKHR
{
public:
+ using CType = VkSurfaceKHR;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR;
+
+ public:
VULKAN_HPP_CONSTEXPR SurfaceKHR()
: m_surfaceKHR(VK_NULL_HANDLE)
{}
@@ -11576,9 +13402,20 @@
};
static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eSurfaceKHR>
+ {
+ using type = SurfaceKHR;
+ };
+
class DebugReportCallbackEXT
{
public:
+ using CType = VkDebugReportCallbackEXT;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT;
+
+ public:
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
: m_debugReportCallbackEXT(VK_NULL_HANDLE)
{}
@@ -11640,9 +13477,20 @@
};
static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDebugReportCallbackEXT>
+ {
+ using type = DebugReportCallbackEXT;
+ };
+
class DebugUtilsMessengerEXT
{
public:
+ using CType = VkDebugUtilsMessengerEXT;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT;
+
+ public:
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
: m_debugUtilsMessengerEXT(VK_NULL_HANDLE)
{}
@@ -11704,9 +13552,20 @@
};
static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDebugUtilsMessengerEXT>
+ {
+ using type = DebugUtilsMessengerEXT;
+ };
+
class DisplayKHR
{
public:
+ using CType = VkDisplayKHR;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR;
+
+ public:
VULKAN_HPP_CONSTEXPR DisplayKHR()
: m_displayKHR(VK_NULL_HANDLE)
{}
@@ -11768,9 +13627,20 @@
};
static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDisplayKHR>
+ {
+ using type = DisplayKHR;
+ };
+
class SwapchainKHR
{
public:
+ using CType = VkSwapchainKHR;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR;
+
+ public:
VULKAN_HPP_CONSTEXPR SwapchainKHR()
: m_swapchainKHR(VK_NULL_HANDLE)
{}
@@ -11832,9 +13702,20 @@
};
static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eSwapchainKHR>
+ {
+ using type = SwapchainKHR;
+ };
+
class Semaphore
{
public:
+ using CType = VkSemaphore;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore;
+
+ public:
VULKAN_HPP_CONSTEXPR Semaphore()
: m_semaphore(VK_NULL_HANDLE)
{}
@@ -11896,9 +13777,20 @@
};
static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eSemaphore>
+ {
+ using type = Semaphore;
+ };
+
class Fence
{
public:
+ using CType = VkFence;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence;
+
+ public:
VULKAN_HPP_CONSTEXPR Fence()
: m_fence(VK_NULL_HANDLE)
{}
@@ -11960,9 +13852,20 @@
};
static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eFence>
+ {
+ using type = Fence;
+ };
+
class PerformanceConfigurationINTEL
{
public:
+ using CType = VkPerformanceConfigurationINTEL;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL;
+
+ public:
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()
: m_performanceConfigurationINTEL(VK_NULL_HANDLE)
{}
@@ -12024,9 +13927,20 @@
};
static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::ePerformanceConfigurationINTEL>
+ {
+ using type = PerformanceConfigurationINTEL;
+ };
+
class QueryPool
{
public:
+ using CType = VkQueryPool;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool;
+
+ public:
VULKAN_HPP_CONSTEXPR QueryPool()
: m_queryPool(VK_NULL_HANDLE)
{}
@@ -12088,9 +14002,20 @@
};
static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eQueryPool>
+ {
+ using type = QueryPool;
+ };
+
class Buffer
{
public:
+ using CType = VkBuffer;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer;
+
+ public:
VULKAN_HPP_CONSTEXPR Buffer()
: m_buffer(VK_NULL_HANDLE)
{}
@@ -12152,9 +14077,20 @@
};
static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eBuffer>
+ {
+ using type = Buffer;
+ };
+
class PipelineLayout
{
public:
+ using CType = VkPipelineLayout;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout;
+
+ public:
VULKAN_HPP_CONSTEXPR PipelineLayout()
: m_pipelineLayout(VK_NULL_HANDLE)
{}
@@ -12216,9 +14152,20 @@
};
static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::ePipelineLayout>
+ {
+ using type = PipelineLayout;
+ };
+
class DescriptorSet
{
public:
+ using CType = VkDescriptorSet;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet;
+
+ public:
VULKAN_HPP_CONSTEXPR DescriptorSet()
: m_descriptorSet(VK_NULL_HANDLE)
{}
@@ -12280,9 +14227,20 @@
};
static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDescriptorSet>
+ {
+ using type = DescriptorSet;
+ };
+
class Pipeline
{
public:
+ using CType = VkPipeline;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline;
+
+ public:
VULKAN_HPP_CONSTEXPR Pipeline()
: m_pipeline(VK_NULL_HANDLE)
{}
@@ -12344,9 +14302,20 @@
};
static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::ePipeline>
+ {
+ using type = Pipeline;
+ };
+
class ImageView
{
public:
+ using CType = VkImageView;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView;
+
+ public:
VULKAN_HPP_CONSTEXPR ImageView()
: m_imageView(VK_NULL_HANDLE)
{}
@@ -12408,9 +14377,20 @@
};
static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eImageView>
+ {
+ using type = ImageView;
+ };
+
class Image
{
public:
+ using CType = VkImage;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage;
+
+ public:
VULKAN_HPP_CONSTEXPR Image()
: m_image(VK_NULL_HANDLE)
{}
@@ -12472,9 +14452,20 @@
};
static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eImage>
+ {
+ using type = Image;
+ };
+
class AccelerationStructureNV
{
public:
+ using CType = VkAccelerationStructureNV;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV;
+
+ public:
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
: m_accelerationStructureNV(VK_NULL_HANDLE)
{}
@@ -12536,9 +14527,20 @@
};
static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eAccelerationStructureNV>
+ {
+ using type = AccelerationStructureNV;
+ };
+
class DescriptorUpdateTemplate
{
public:
+ using CType = VkDescriptorUpdateTemplate;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate;
+
+ public:
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
: m_descriptorUpdateTemplate(VK_NULL_HANDLE)
{}
@@ -12599,11 +14601,22 @@
VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
};
static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
+
+ template <>
+ struct cpp_type<ObjectType::eDescriptorUpdateTemplate>
+ {
+ using type = DescriptorUpdateTemplate;
+ };
using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
class Event
{
public:
+ using CType = VkEvent;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent;
+
+ public:
VULKAN_HPP_CONSTEXPR Event()
: m_event(VK_NULL_HANDLE)
{}
@@ -12665,9 +14678,20 @@
};
static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eEvent>
+ {
+ using type = Event;
+ };
+
class CommandBuffer
{
public:
+ using CType = VkCommandBuffer;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer;
+
+ public:
VULKAN_HPP_CONSTEXPR CommandBuffer()
: m_commandBuffer(VK_NULL_HANDLE)
{}
@@ -12709,479 +14733,482 @@
return m_commandBuffer < rhs.m_commandBuffer;
}
- template<typename Dispatch = DispatchLoaderDefault>
- Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result begin( const vk::CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginConditionalRenderingEXT( const vk::ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginQuery( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginRenderPass( const vk::RenderPassBeginInfo* pRenderPassBegin, vk::SubpassContents contents, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, vk::SubpassContents contents, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginRenderPass2KHR( const vk::RenderPassBeginInfo* pRenderPassBegin, const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, ArrayProxy<const vk::DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindIndexBuffer( vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindPipeline( vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindShadingRateImageNV( vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, const vk::DeviceSize* pSizes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, ArrayProxy<const vk::DeviceSize> sizes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageBlit* pRegions, vk::Filter filter, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageBlit> regions, vk::Filter filter, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void buildAccelerationStructureNV( const vk::AccelerationStructureInfoNV* pInfo, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void clearAttachments( uint32_t attachmentCount, const vk::ClearAttachment* pAttachments, uint32_t rectCount, const vk::ClearRect* pRects, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void clearAttachments( ArrayProxy<const vk::ClearAttachment> attachments, ArrayProxy<const vk::ClearRect> rects, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue* pColor, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyAccelerationStructureNV( vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeNV mode, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferCopy* pRegions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferCopy> regions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageCopy* pRegions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageCopy> regions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void copyQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugMarkerBeginEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugMarkerEndEXT(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugMarkerInsertEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void dispatchIndirect( vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndexedIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndexedIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndexedIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawMeshTasksIndirectCountNV( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawMeshTasksIndirectNV( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void endConditionalRenderingEXT(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endConditionalRenderingEXT(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endDebugUtilsLabelEXT(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endQuery( vk::QueryPool queryPool, uint32_t query, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void endRenderPass(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endRenderPass(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endRenderPass2KHR( const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void executeCommands( uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void executeCommands( ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void fillBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void nextSubpass( vk::SubpassContents contents, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void nextSubpass2KHR( const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- 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, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void processCommandsNVX( const vk::CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename T, typename Dispatch = DispatchLoaderDefault>
- void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = Dispatch() ) const;
+ template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void pushDescriptorSetWithTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void reserveSpaceForCommandsNVX( const vk::CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void resetEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void resetQueryPool( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageResolve* pRegions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageResolve> regions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setBlendConstants( const float blendConstants[4], Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const vk::CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setDeviceMask( uint32_t deviceMask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const vk::Rect2D* pDiscardRectangles, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const vk::Rect2D> discardRectangles, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Rect2D* pExclusiveScissors, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const vk::Rect2D> exclusiveScissors, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setLineWidth( float lineWidth, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setPerformanceMarkerINTEL( const vk::PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setPerformanceOverrideINTEL( const vk::PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setPerformanceStreamMarkerINTEL( const vk::PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setSampleLocationsEXT( const vk::SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setScissor( uint32_t firstScissor, uint32_t scissorCount, const vk::Rect2D* pScissors, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setScissor( uint32_t firstScissor, ArrayProxy<const vk::Rect2D> scissors, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setStencilCompareMask( vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setStencilReference( vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setStencilWriteMask( vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setViewport( uint32_t firstViewport, uint32_t viewportCount, const vk::Viewport* pViewports, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setViewport( uint32_t firstViewport, ArrayProxy<const vk::Viewport> viewports, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const vk::ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportWScalingNV* pViewportWScalings, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const vk::ViewportWScalingNV> viewportWScalings, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void traceRaysNV( vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize dataSize, const void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename T, typename Dispatch = DispatchLoaderDefault>
- void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = Dispatch() ) const;
+ template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- 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, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void waitEvents( uint32_t eventCount, const vk::Event* pEvents, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void waitEvents( ArrayProxy<const vk::Event> events, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const vk::AccelerationStructureNV* pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void writeAccelerationStructuresPropertiesNV( ArrayProxy<const vk::AccelerationStructureNV> accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void writeBufferMarkerAMD( vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void writeTimestamp( vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result end(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result end(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type end(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type end(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result reset( vk::CommandBufferResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type reset( vk::CommandBufferResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
@@ -13204,9 +15231,20 @@
};
static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eCommandBuffer>
+ {
+ using type = CommandBuffer;
+ };
+
class DeviceMemory
{
public:
+ using CType = VkDeviceMemory;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory;
+
+ public:
VULKAN_HPP_CONSTEXPR DeviceMemory()
: m_deviceMemory(VK_NULL_HANDLE)
{}
@@ -13268,9 +15306,20 @@
};
static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDeviceMemory>
+ {
+ using type = DeviceMemory;
+ };
+
class BufferView
{
public:
+ using CType = VkBufferView;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView;
+
+ public:
VULKAN_HPP_CONSTEXPR BufferView()
: m_bufferView(VK_NULL_HANDLE)
{}
@@ -13332,9 +15381,20 @@
};
static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eBufferView>
+ {
+ using type = BufferView;
+ };
+
class CommandPool
{
public:
+ using CType = VkCommandPool;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool;
+
+ public:
VULKAN_HPP_CONSTEXPR CommandPool()
: m_commandPool(VK_NULL_HANDLE)
{}
@@ -13396,9 +15456,20 @@
};
static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eCommandPool>
+ {
+ using type = CommandPool;
+ };
+
class PipelineCache
{
public:
+ using CType = VkPipelineCache;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache;
+
+ public:
VULKAN_HPP_CONSTEXPR PipelineCache()
: m_pipelineCache(VK_NULL_HANDLE)
{}
@@ -13460,9 +15531,20 @@
};
static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::ePipelineCache>
+ {
+ using type = PipelineCache;
+ };
+
class DescriptorPool
{
public:
+ using CType = VkDescriptorPool;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool;
+
+ public:
VULKAN_HPP_CONSTEXPR DescriptorPool()
: m_descriptorPool(VK_NULL_HANDLE)
{}
@@ -13524,9 +15606,20 @@
};
static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDescriptorPool>
+ {
+ using type = DescriptorPool;
+ };
+
class DescriptorSetLayout
{
public:
+ using CType = VkDescriptorSetLayout;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout;
+
+ public:
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
: m_descriptorSetLayout(VK_NULL_HANDLE)
{}
@@ -13588,9 +15681,20 @@
};
static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDescriptorSetLayout>
+ {
+ using type = DescriptorSetLayout;
+ };
+
class Framebuffer
{
public:
+ using CType = VkFramebuffer;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer;
+
+ public:
VULKAN_HPP_CONSTEXPR Framebuffer()
: m_framebuffer(VK_NULL_HANDLE)
{}
@@ -13652,9 +15756,20 @@
};
static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eFramebuffer>
+ {
+ using type = Framebuffer;
+ };
+
class IndirectCommandsLayoutNVX
{
public:
+ using CType = VkIndirectCommandsLayoutNVX;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNVX;
+
+ public:
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
: m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
{}
@@ -13716,9 +15831,20 @@
};
static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eIndirectCommandsLayoutNVX>
+ {
+ using type = IndirectCommandsLayoutNVX;
+ };
+
class ObjectTableNVX
{
public:
+ using CType = VkObjectTableNVX;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eObjectTableNVX;
+
+ public:
VULKAN_HPP_CONSTEXPR ObjectTableNVX()
: m_objectTableNVX(VK_NULL_HANDLE)
{}
@@ -13780,9 +15906,20 @@
};
static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eObjectTableNVX>
+ {
+ using type = ObjectTableNVX;
+ };
+
class RenderPass
{
public:
+ using CType = VkRenderPass;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass;
+
+ public:
VULKAN_HPP_CONSTEXPR RenderPass()
: m_renderPass(VK_NULL_HANDLE)
{}
@@ -13844,9 +15981,20 @@
};
static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eRenderPass>
+ {
+ using type = RenderPass;
+ };
+
class Sampler
{
public:
+ using CType = VkSampler;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler;
+
+ public:
VULKAN_HPP_CONSTEXPR Sampler()
: m_sampler(VK_NULL_HANDLE)
{}
@@ -13908,9 +16056,20 @@
};
static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eSampler>
+ {
+ using type = Sampler;
+ };
+
class SamplerYcbcrConversion
{
public:
+ using CType = VkSamplerYcbcrConversion;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion;
+
+ public:
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
: m_samplerYcbcrConversion(VK_NULL_HANDLE)
{}
@@ -13971,11 +16130,22 @@
VkSamplerYcbcrConversion m_samplerYcbcrConversion;
};
static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
+
+ template <>
+ struct cpp_type<ObjectType::eSamplerYcbcrConversion>
+ {
+ using type = SamplerYcbcrConversion;
+ };
using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
class ShaderModule
{
public:
+ using CType = VkShaderModule;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule;
+
+ public:
VULKAN_HPP_CONSTEXPR ShaderModule()
: m_shaderModule(VK_NULL_HANDLE)
{}
@@ -14037,9 +16207,20 @@
};
static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eShaderModule>
+ {
+ using type = ShaderModule;
+ };
+
class ValidationCacheEXT
{
public:
+ using CType = VkValidationCacheEXT;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT;
+
+ public:
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
: m_validationCacheEXT(VK_NULL_HANDLE)
{}
@@ -14101,9 +16282,20 @@
};
static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eValidationCacheEXT>
+ {
+ using type = ValidationCacheEXT;
+ };
+
class Queue
{
public:
+ using CType = VkQueue;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue;
+
+ public:
VULKAN_HPP_CONSTEXPR Queue()
: m_queue(VK_NULL_HANDLE)
{}
@@ -14145,67 +16337,67 @@
return m_queue < rhs.m_queue;
}
- template<typename Dispatch = DispatchLoaderDefault>
- void getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getCheckpointDataNV( uint32_t* pCheckpointDataCount, vk::CheckpointDataNV* pCheckpointData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderDefault>
- std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindSparse( uint32_t bindInfoCount, const vk::BindSparseInfo* pBindInfo, vk::Fence fence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindSparse( ArrayProxy<const vk::BindSparseInfo> bindInfo, vk::Fence fence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void endDebugUtilsLabelEXT(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result presentKHR( const vk::PresentInfoKHR* pPresentInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result submit( uint32_t submitCount, const vk::SubmitInfo* pSubmits, vk::Fence fence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type submit( ArrayProxy<const vk::SubmitInfo> submits, vk::Fence fence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result waitIdle(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result waitIdle(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type waitIdle(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const
@@ -14228,69 +16420,80 @@
};
static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eQueue>
+ {
+ using type = Queue;
+ };
+
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Device;
template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, DispatchLoaderDefault>;
+ using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Buffer, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueBuffer = UniqueHandle<Buffer, DispatchLoaderDefault>;
+ using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<BufferView, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueBufferView = UniqueHandle<BufferView, DispatchLoaderDefault>;
+ using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<CommandBuffer, Dispatch> { public: using deleter = PoolFree<Device, CommandPool, Dispatch>; };
- using UniqueCommandBuffer = UniqueHandle<CommandBuffer, DispatchLoaderDefault>;
+ using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<CommandPool, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueCommandPool = UniqueHandle<CommandPool, DispatchLoaderDefault>;
+ using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<DescriptorPool, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueDescriptorPool = UniqueHandle<DescriptorPool, DispatchLoaderDefault>;
+ using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<DescriptorSet, Dispatch> { public: using deleter = PoolFree<Device, DescriptorPool, Dispatch>; };
- using UniqueDescriptorSet = UniqueHandle<DescriptorSet, DispatchLoaderDefault>;
+ using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<DescriptorSetLayout, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, DispatchLoaderDefault>;
+ using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, DispatchLoaderDefault>;
+ using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<DeviceMemory, Dispatch> { public: using deleter = ObjectFree<Device, Dispatch>; };
- using UniqueDeviceMemory = UniqueHandle<DeviceMemory, DispatchLoaderDefault>;
+ using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Event, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueEvent = UniqueHandle<Event, DispatchLoaderDefault>;
+ using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Fence, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueFence = UniqueHandle<Fence, DispatchLoaderDefault>;
+ using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Framebuffer, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueFramebuffer = UniqueHandle<Framebuffer, DispatchLoaderDefault>;
+ using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Image, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueImage = UniqueHandle<Image, DispatchLoaderDefault>;
+ using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<ImageView, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueImageView = UniqueHandle<ImageView, DispatchLoaderDefault>;
+ using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<IndirectCommandsLayoutNVX, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX, DispatchLoaderDefault>;
+ using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<ObjectTableNVX, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX, DispatchLoaderDefault>;
+ using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Pipeline, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniquePipeline = UniqueHandle<Pipeline, DispatchLoaderDefault>;
+ using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<PipelineCache, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniquePipelineCache = UniqueHandle<PipelineCache, DispatchLoaderDefault>;
+ using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<PipelineLayout, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniquePipelineLayout = UniqueHandle<PipelineLayout, DispatchLoaderDefault>;
+ using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<QueryPool, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueQueryPool = UniqueHandle<QueryPool, DispatchLoaderDefault>;
+ using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<RenderPass, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueRenderPass = UniqueHandle<RenderPass, DispatchLoaderDefault>;
+ using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Sampler, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueSampler = UniqueHandle<Sampler, DispatchLoaderDefault>;
+ using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, DispatchLoaderDefault>;
+ using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<Semaphore, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueSemaphore = UniqueHandle<Semaphore, DispatchLoaderDefault>;
+ using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<ShaderModule, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueShaderModule = UniqueHandle<ShaderModule, DispatchLoaderDefault>;
+ using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<SwapchainKHR, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, DispatchLoaderDefault>;
+ using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<ValidationCacheEXT, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; };
- using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, DispatchLoaderDefault>;
+ using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Device
{
public:
+ using CType = VkDevice;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice;
+
+ public:
VULKAN_HPP_CONSTEXPR Device()
: m_device(VK_NULL_HANDLE)
{}
@@ -14334,1573 +16537,1621 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result acquireNextImage2KHR( const vk::AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, uint32_t* pImageIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValue<uint32_t> acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result acquirePerformanceConfigurationINTEL( const vk::PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, vk::PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::PerformanceConfigurationINTEL>::type acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result allocateDescriptorSets( const vk::DescriptorSetAllocateInfo* pAllocateInfo, vk::DescriptorSet* pDescriptorSets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result allocateMemory( const vk::MemoryAllocateInfo* pAllocateInfo, const vk::AllocationCallbacks* pAllocator, vk::DeviceMemory* pMemory, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const vk::BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindAccelerationStructureMemoryNV( ArrayProxy<const vk::BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindBufferMemory2( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindBufferMemory2( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindBufferMemory2KHR( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindImageMemory2( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindImageMemory2( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result bindImageMemory2KHR( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createAccelerationStructureNV( const vk::AccelerationStructureCreateInfoNV* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::AccelerationStructureNV>::type createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createBuffer( const vk::BufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Buffer* pBuffer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createBufferView( const vk::BufferViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::BufferView* pView, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createCommandPool( const vk::CommandPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::CommandPool* pCommandPool, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createComputePipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ComputePipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<Pipeline>::type createComputePipeline( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDescriptorPool( const vk::DescriptorPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorPool* pDescriptorPool, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDescriptorSetLayout( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorSetLayout* pSetLayout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDescriptorUpdateTemplate( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDescriptorUpdateTemplateKHR( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DescriptorUpdateTemplate>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createEvent( const vk::EventCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Event* pEvent, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Event,Dispatch>>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Event,Dispatch>>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createFence( const vk::FenceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createFramebuffer( const vk::FramebufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Framebuffer* pFramebuffer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createGraphicsPipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::GraphicsPipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<Pipeline>::type createGraphicsPipeline( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createImage( const vk::ImageCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Image* pImage, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Image,Dispatch>>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Image,Dispatch>>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createImageView( const vk::ImageViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ImageView* pView, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createIndirectCommandsLayoutNVX( const vk::IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createObjectTableNVX( const vk::ObjectTableCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ObjectTableNVX* pObjectTable, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createPipelineCache( const vk::PipelineCacheCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineCache* pPipelineCache, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createPipelineLayout( const vk::PipelineLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineLayout* pPipelineLayout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createQueryPool( const vk::QueryPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::QueryPool* pQueryPool, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoNV* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Pipeline>::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Pipeline,Allocator>>::type createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<Pipeline>::type createRayTracingPipelineNV( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createRayTracingPipelineNVUnique( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createRenderPass( const vk::RenderPassCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createRenderPass2KHR( const vk::RenderPassCreateInfo2KHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createSampler( const vk::SamplerCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Sampler* pSampler, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createSamplerYcbcrConversion( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SamplerYcbcrConversion>::type createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createSamplerYcbcrConversionKHR( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SamplerYcbcrConversion>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createSemaphore( const vk::SemaphoreCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Semaphore* pSemaphore, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createShaderModule( const vk::ShaderModuleCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ShaderModule* pShaderModule, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createSharedSwapchainsKHR( uint32_t swapchainCount, const vk::SwapchainCreateInfoKHR* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchains, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createSwapchainKHR( const vk::SwapchainCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createValidationCacheEXT( const vk::ValidationCacheCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ValidationCacheEXT* pValidationCache, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result debugMarkerSetObjectNameEXT( const vk::DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result debugMarkerSetObjectTagEXT( const vk::DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyBuffer( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyBuffer( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyBufferView( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyBufferView( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyCommandPool( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyCommandPool( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorPool( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorPool( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyEvent( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyEvent( vk::Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyFence( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyFence( vk::Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyFramebuffer( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyFramebuffer( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyImage( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyImage( vk::Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyImageView( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyImageView( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyObjectTableNVX( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyObjectTableNVX( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyPipeline( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyPipeline( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyPipelineCache( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyPipelineCache( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyPipelineLayout( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyPipelineLayout( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyQueryPool( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyQueryPool( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyRenderPass( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyRenderPass( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySampler( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySampler( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySemaphore( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySemaphore( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyShaderModule( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyShaderModule( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySwapchainKHR( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySwapchainKHR( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result waitIdle(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result waitIdle(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type waitIdle(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result displayPowerControlEXT( vk::DisplayKHR display, const vk::DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type displayPowerControlEXT( vk::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void freeCommandBuffers( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void freeCommandBuffers( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void free( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void free( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result freeDescriptorSets( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type freeDescriptorSets( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result free( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type free( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void freeMemory( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void freeMemory( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void free( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void free( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename T, typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+ template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getAccelerationStructureMemoryRequirementsNV( const vk::AccelerationStructureMemoryRequirementsInfoNV* pInfo, vk::MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, vk::AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ DeviceAddress getBufferAddressEXT( const vk::BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfoEXT & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getBufferMemoryRequirements( vk::Buffer buffer, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements getBufferMemoryRequirements( vk::Buffer buffer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getBufferMemoryRequirements2( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getBufferMemoryRequirements2KHR( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getCalibratedTimestampsEXT( uint32_t timestampCount, const vk::CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<uint64_t>::type getCalibratedTimestampsEXT( ArrayProxy<const vk::CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getDescriptorSetLayoutSupport( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getDescriptorSetLayoutSupportKHR( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getGroupPresentCapabilitiesKHR( vk::DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DeviceGroupPresentCapabilitiesKHR>::type getGroupPresentCapabilitiesKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getGroupSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getMemoryCommitment( vk::DeviceMemory memory, vk::DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::DeviceSize getMemoryCommitment( vk::DeviceMemory memory, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, vk::Queue* pQueue, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getQueue2( const vk::DeviceQueueInfo2* pQueueInfo, vk::Queue* pQueue, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getEventStatus( vk::Event event, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getFenceFdKHR( const vk::FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getFenceStatus( vk::Fence fence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getFenceWin32HandleKHR( const vk::FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getImageDrmFormatModifierPropertiesEXT( vk::Image image, vk::ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ImageDrmFormatModifierPropertiesEXT>::type getImageDrmFormatModifierPropertiesEXT( vk::Image image, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageMemoryRequirements( vk::Image image, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements getImageMemoryRequirements( vk::Image image, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageMemoryRequirements2( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageMemoryRequirements2KHR( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageSparseMemoryRequirements( vk::Image image, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( vk::Image image, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( vk::Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageSparseMemoryRequirements2( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageSparseMemoryRequirements2KHR( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getImageSubresourceLayout( vk::Image image, const vk::ImageSubresource* pSubresource, vk::SubresourceLayout* pLayout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::SubresourceLayout getImageSubresourceLayout( vk::Image image, const ImageSubresource & subresource, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX* pInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ uint32_t getImageViewHandleNVX( const vk::ImageViewHandleInfoNVX* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryAndroidHardwareBufferANDROID( const vk::MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<struct AHardwareBuffer*>::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<struct AHardwareBuffer*>::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryFdKHR( const vk::MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, vk::MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, vk::MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryWin32HandleKHR( const vk::MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<HANDLE>::type getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, vk::MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, vk::PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, PerformanceValueINTEL* pValue, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, vk::PerformanceValueINTEL* pValue, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<PerformanceValueINTEL>::type getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::PerformanceValueINTEL>::type getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPipelineCacheData( vk::PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( vk::PipelineCache pipelineCache, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( vk::PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPipelineExecutableInternalRepresentationsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR* pInternalRepresentations, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename T, typename Dispatch = DispatchLoaderDefault>
- Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PipelineExecutableInternalRepresentationKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPipelineExecutablePropertiesKHR( const vk::PipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, vk::PipelineExecutablePropertiesKHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename T, typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PipelineExecutablePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPipelineExecutableStatisticsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, vk::PipelineExecutableStatisticKHR* pStatistics, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Allocator = std::allocator<PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PipelineExecutableStatisticKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const;
+ template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, vk::RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getRenderAreaGranularity( vk::RenderPass renderPass, vk::Extent2D* pGranularity, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::Extent2D getRenderAreaGranularity( vk::RenderPass renderPass, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSemaphoreCounterValueKHR( vk::Semaphore semaphore, uint64_t* pValue, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<uint64_t>::type getSemaphoreCounterValueKHR( vk::Semaphore semaphore, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSemaphoreFdKHR( const vk::SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSemaphoreWin32HandleKHR( const vk::SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<uint64_t>::type getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<uint64_t>::type getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSwapchainImagesKHR( vk::SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, vk::Image* pSwapchainImages, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSwapchainStatusKHR( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result importFenceFdKHR( const vk::ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result importFenceWin32HandleKHR( const vk::ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result importSemaphoreFdKHR( const vk::ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result importSemaphoreWin32HandleKHR( const vk::ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result initializePerformanceApiINTEL( const vk::InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, void** ppData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void*>::type mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags = MemoryMapFlags(), Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result mergePipelineCaches( vk::PipelineCache dstCache, uint32_t srcCacheCount, const vk::PipelineCache* pSrcCaches, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type mergePipelineCaches( vk::PipelineCache dstCache, ArrayProxy<const vk::PipelineCache> srcCaches, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const vk::ValidationCacheEXT* pSrcCaches, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, ArrayProxy<const vk::ValidationCacheEXT> srcCaches, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result registerEventEXT( const vk::DeviceEventInfoEXT* pDeviceEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result registerDisplayEventEXT( vk::DisplayKHR display, const vk::DisplayEventInfoEXT* pDisplayEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Fence>::type registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result registerObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type registerObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result resetEvent( vk::Event event, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type resetEvent( vk::Event event, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result resetFences( uint32_t fenceCount, const vk::Fence* pFences, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type resetFences( ArrayProxy<const vk::Fence> fences, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void resetQueryPoolEXT( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setDebugUtilsObjectNameEXT( const vk::DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setDebugUtilsObjectTagEXT( const vk::DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result setEvent( Event event, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result setEvent( vk::Event event, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type setEvent( Event event, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type setEvent( vk::Event event, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setHdrMetadataEXT( uint32_t swapchainCount, const vk::SwapchainKHR* pSwapchains, const vk::HdrMetadataEXT* pMetadata, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setHdrMetadataEXT( ArrayProxy<const vk::SwapchainKHR> swapchains, ArrayProxy<const vk::HdrMetadataEXT> metadata, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void setLocalDimmingAMD( vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
-
- template<typename Dispatch = DispatchLoaderDefault>
- void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
-
- template<typename Dispatch = DispatchLoaderDefault>
- void uninitializePerformanceApiINTEL(Dispatch const &d = Dispatch() ) const;
-
- template<typename Dispatch = DispatchLoaderDefault>
- void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
-
- template<typename Dispatch = DispatchLoaderDefault>
- Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result signalSemaphoreKHR( const vk::SemaphoreSignalInfoKHR* pSignalInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type signalSemaphoreKHR( const SemaphoreSignalInfoKHR & signalInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void trimCommandPool( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void trimCommandPoolKHR( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
- template<typename Dispatch = DispatchLoaderDefault>
- void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void uninitializePerformanceApiINTEL(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void unmapMemory( vk::DeviceMemory memory, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result unregisterObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type unregisterObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void updateDescriptorSetWithTemplate( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void updateDescriptorSetWithTemplateKHR( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void updateDescriptorSets( uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const vk::CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void updateDescriptorSets( ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, ArrayProxy<const vk::CopyDescriptorSet> descriptorCopies, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result waitForFences( uint32_t fenceCount, const vk::Fence* pFences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result waitForFences( ArrayProxy<const vk::Fence> fences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result waitSemaphoresKHR( const vk::SemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result waitSemaphoresKHR( const SemaphoreWaitInfoKHR & waitInfo, uint64_t timeout, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
@@ -15923,9 +18174,20 @@
};
static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDevice>
+ {
+ using type = Device;
+ };
+
class DisplayModeKHR
{
public:
+ using CType = VkDisplayModeKHR;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR;
+
+ public:
VULKAN_HPP_CONSTEXPR DisplayModeKHR()
: m_displayModeKHR(VK_NULL_HANDLE)
{}
@@ -15987,14 +18249,25 @@
};
static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eDisplayModeKHR>
+ {
+ using type = DisplayModeKHR;
+ };
+
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
- using UniqueDevice = UniqueHandle<Device, DispatchLoaderDefault>;
+ using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class PhysicalDevice
{
public:
+ using CType = VkPhysicalDevice;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice;
+
+ public:
VULKAN_HPP_CONSTEXPR PhysicalDevice()
: m_physicalDevice(VK_NULL_HANDLE)
{}
@@ -16037,528 +18310,528 @@
}
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
- template<typename Dispatch = DispatchLoaderDefault>
- Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result acquireXlibDisplayEXT( Display* dpy, vk::DisplayKHR display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<Display>::type acquireXlibDisplayEXT( vk::DisplayKHR display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDevice( const vk::DeviceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Device* pDevice, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Device,Dispatch>>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Device,Dispatch>>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDisplayModeKHR( vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DisplayModeKHR* pMode, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DisplayModeKHR>::type createDisplayModeKHR( vk::DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( vk::DisplayKHR display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayModePropertiesKHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModePropertiesKHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( vk::DisplayKHR display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayPlaneCapabilities2KHR( const vk::DisplayPlaneInfo2KHR* pDisplayPlaneInfo, vk::DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DisplayPlaneCapabilities2KHR>::type getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, vk::DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, vk::DisplayKHR* pDisplays, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, vk::TimeDomainEXT* pTimeDomains, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, vk::CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<CooperativeMatrixPropertiesNV>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV,Allocator>>::type getCooperativeMatrixPropertiesNV(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<CooperativeMatrixPropertiesNV>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV,Allocator>>::type getCooperativeMatrixPropertiesNV(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<CooperativeMatrixPropertiesNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV,Allocator>>::type getCooperativeMatrixPropertiesNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, vk::DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayProperties2KHR( uint32_t* pPropertyCount, vk::DisplayProperties2KHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPropertiesKHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getExternalBufferProperties( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getExternalBufferPropertiesKHR( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getExternalFenceProperties( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getExternalFencePropertiesKHR( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, vk::ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getExternalSemaphoreProperties( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getExternalSemaphorePropertiesKHR( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getFeatures( vk::PhysicalDeviceFeatures* pFeatures, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceFeatures getFeatures(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getFeatures2( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getFeatures2KHR( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getFormatProperties( vk::Format format, vk::FormatProperties* pFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::FormatProperties getFormatProperties( vk::Format format, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getFormatProperties2( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::FormatProperties2 getFormatProperties2( vk::Format format, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getFormatProperties2( vk::Format format, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getFormatProperties2KHR( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::FormatProperties2 getFormatProperties2KHR( vk::Format format, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getFormatProperties2KHR( vk::Format format, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getGeneratedCommandsPropertiesNVX( vk::DeviceGeneratedCommandsFeaturesNVX* pFeatures, vk::DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ImageFormatProperties* pImageFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ImageFormatProperties>::type getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getImageFormatProperties2( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ImageFormatProperties2>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getImageFormatProperties2KHR( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::ImageFormatProperties2>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getMemoryProperties( vk::PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getMemoryProperties2( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getMemoryProperties2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getMemoryProperties2KHR( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getMemoryProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, vk::MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::MultisamplePropertiesEXT getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getPresentRectanglesKHR( vk::SurfaceKHR surface, uint32_t* pRectCount, vk::Rect2D* pRects, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getProperties( vk::PhysicalDeviceProperties* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceProperties getProperties(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getProperties2( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceProperties2 getProperties2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getProperties2KHR( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ vk::PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderDefault>
- std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderDefault>
- std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderDefault>
- std::vector<StructureChain,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
- template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderDefault>
+ template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<StructureChain,Allocator> getQueueFamilyProperties2(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<StructureChain,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderDefault>
- std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
- template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderDefault>
- std::vector<StructureChain,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
- template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = DispatchLoaderDefault>
+ template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<StructureChain,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename StructureChain, typename Allocator = std::allocator<StructureChain>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<StructureChain,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, uint32_t* pPropertyCount, vk::SparseImageFormatProperties* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getSparseImageFormatProperties2( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void getSparseImageFormatProperties2KHR( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderDefault>
- std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, vk::FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<FramebufferMixedSamplesCombinationNV>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV,Allocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<FramebufferMixedSamplesCombinationNV>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV,Allocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<FramebufferMixedSamplesCombinationNV>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<FramebufferMixedSamplesCombinationNV,Allocator>>::type getSupportedFramebufferMixedSamplesCombinationsNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, vk::SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfaceCapabilities2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
- template<typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename X, typename Y, typename ...Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, vk::SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfaceFormats2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, vk::SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfaceFormatsKHR( vk::SurfaceKHR surface, uint32_t* pSurfaceFormatCount, vk::SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfacePresentModesKHR( vk::SurfaceKHR surface, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
+ template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, vk::Bool32* pSupported, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_XCB_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#ifdef VK_USE_PLATFORM_XLIB_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
- template<typename Dispatch = DispatchLoaderDefault>
- Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, vk::DisplayKHR* pDisplay, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#else
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
@@ -16581,19 +18854,30 @@
};
static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::ePhysicalDevice>
+ {
+ using type = PhysicalDevice;
+ };
+
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Instance;
template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
- using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, DispatchLoaderDefault>;
+ using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
- using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, DispatchLoaderDefault>;
+ using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch> class UniqueHandleTraits<SurfaceKHR, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; };
- using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, DispatchLoaderDefault>;
+ using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Instance
{
public:
+ using CType = VkInstance;
+
+ static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance;
+
+ public:
VULKAN_HPP_CONSTEXPR Instance()
: m_instance(VK_NULL_HANDLE)
{}
@@ -16636,287 +18920,287 @@
}
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createAndroidSurfaceKHR( const vk::AndroidSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDebugReportCallbackEXT( const vk::DebugReportCallbackCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugReportCallbackEXT* pCallback, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDebugUtilsMessengerEXT( const vk::DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createDisplayPlaneSurfaceKHR( const vk::DisplaySurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createHeadlessSurfaceEXT( const vk::HeadlessSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VK_USE_PLATFORM_IOS_MVK
- template<typename Dispatch = DispatchLoaderDefault>
- Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createIOSSurfaceMVK( const vk::IOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#ifdef VK_USE_PLATFORM_FUCHSIA
- template<typename Dispatch = DispatchLoaderDefault>
- Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createImagePipeSurfaceFUCHSIA( const vk::ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#ifdef VK_USE_PLATFORM_MACOS_MVK
- template<typename Dispatch = DispatchLoaderDefault>
- Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createMacOSSurfaceMVK( const vk::MacOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
#ifdef VK_USE_PLATFORM_METAL_EXT
- template<typename Dispatch = DispatchLoaderDefault>
- Result createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createMetalSurfaceEXT( const vk::MetalSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_METAL_EXT*/
#ifdef VK_USE_PLATFORM_GGP
- template<typename Dispatch = DispatchLoaderDefault>
- Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createStreamDescriptorSurfaceGGP( const vk::StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_GGP*/
#ifdef VK_USE_PLATFORM_VI_NN
- template<typename Dispatch = DispatchLoaderDefault>
- Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createViSurfaceNN( const vk::ViSurfaceCreateInfoNN* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_VI_NN*/
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createWaylandSurfaceKHR( const vk::WaylandSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createWin32SurfaceKHR( const vk::Win32SurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_XCB_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createXcbSurfaceKHR( const vk::XcbSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#ifdef VK_USE_PLATFORM_XLIB_KHR
- template<typename Dispatch = DispatchLoaderDefault>
- Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createXlibSurfaceKHR( const vk::XlibSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
- template<typename Dispatch = DispatchLoaderDefault>
- void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySurfaceKHR( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroySurfaceKHR( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void destroy( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroups(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties,Allocator>>::type enumeratePhysicalDeviceGroupsKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, vk::PhysicalDevice* pPhysicalDevices, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Dispatch const &d = Dispatch() ) const;
- template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const;
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
@@ -16939,81 +19223,134 @@
};
static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
+ template <>
+ struct cpp_type<ObjectType::eInstance>
+ {
+ using type = Instance;
+ };
+
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; };
- using UniqueInstance = UniqueHandle<Instance, DispatchLoaderDefault>;
+ using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result createInstance( const vk::InstanceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Instance* pInstance, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<vk::Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template<typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() );
- template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
+ template<typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderDefault>
- typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() );
- template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderDefault>
+ template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
+ template<typename Allocator = std::allocator<LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- template<typename Dispatch = DispatchLoaderDefault>
- Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template<typename Dispatch = DispatchLoaderDefault>
- ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = Dispatch() );
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- struct GeometryTrianglesNV
+ namespace layout
{
- GeometryTrianglesNV( Buffer vertexData_ = Buffer(),
- DeviceSize vertexOffset_ = 0,
- uint32_t vertexCount_ = 0,
- DeviceSize vertexStride_ = 0,
- Format vertexFormat_ = Format::eUndefined,
- Buffer indexData_ = Buffer(),
- DeviceSize indexOffset_ = 0,
- uint32_t indexCount_ = 0,
- IndexType indexType_ = IndexType::eUint16,
- Buffer transformData_ = Buffer(),
- DeviceSize transformOffset_ = 0 )
- : vertexData( vertexData_ )
- , vertexOffset( vertexOffset_ )
- , vertexCount( vertexCount_ )
- , vertexStride( vertexStride_ )
- , vertexFormat( vertexFormat_ )
- , indexData( indexData_ )
- , indexOffset( indexOffset_ )
- , indexCount( indexCount_ )
- , indexType( indexType_ )
- , transformData( transformData_ )
- , transformOffset( transformOffset_ )
+ struct GeometryTrianglesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(),
+ vk::DeviceSize vertexOffset_ = 0,
+ uint32_t vertexCount_ = 0,
+ vk::DeviceSize vertexStride_ = 0,
+ vk::Format vertexFormat_ = vk::Format::eUndefined,
+ vk::Buffer indexData_ = vk::Buffer(),
+ vk::DeviceSize indexOffset_ = 0,
+ uint32_t indexCount_ = 0,
+ vk::IndexType indexType_ = vk::IndexType::eUint16,
+ vk::Buffer transformData_ = vk::Buffer(),
+ vk::DeviceSize transformOffset_ = 0 )
+ : vertexData( vertexData_ )
+ , vertexOffset( vertexOffset_ )
+ , vertexCount( vertexCount_ )
+ , vertexStride( vertexStride_ )
+ , vertexFormat( vertexFormat_ )
+ , indexData( indexData_ )
+ , indexOffset( indexOffset_ )
+ , indexCount( indexCount_ )
+ , indexType( indexType_ )
+ , transformData( transformData_ )
+ , transformOffset( transformOffset_ )
+ {}
+
+ GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
+ {
+ *reinterpret_cast<VkGeometryTrianglesNV*>(this) = rhs;
+ }
+
+ GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
+ {
+ *reinterpret_cast<VkGeometryTrianglesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eGeometryTrianglesNV;
+ const void* pNext = nullptr;
+ vk::Buffer vertexData;
+ vk::DeviceSize vertexOffset;
+ uint32_t vertexCount;
+ vk::DeviceSize vertexStride;
+ vk::Format vertexFormat;
+ vk::Buffer indexData;
+ vk::DeviceSize indexOffset;
+ uint32_t indexCount;
+ vk::IndexType indexType;
+ vk::Buffer transformData;
+ vk::DeviceSize transformOffset;
+ };
+ static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct GeometryTrianglesNV : public layout::GeometryTrianglesNV
+ {
+ VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(),
+ vk::DeviceSize vertexOffset_ = 0,
+ uint32_t vertexCount_ = 0,
+ vk::DeviceSize vertexStride_ = 0,
+ vk::Format vertexFormat_ = vk::Format::eUndefined,
+ vk::Buffer indexData_ = vk::Buffer(),
+ vk::DeviceSize indexOffset_ = 0,
+ uint32_t indexCount_ = 0,
+ vk::IndexType indexType_ = vk::IndexType::eUint16,
+ vk::Buffer transformData_ = vk::Buffer(),
+ vk::DeviceSize transformOffset_ = 0 )
+ : layout::GeometryTrianglesNV( vertexData_, vertexOffset_, vertexCount_, vertexStride_, vertexFormat_, indexData_, indexOffset_, indexCount_, indexType_, transformData_, transformOffset_ )
{}
GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
- }
+ : layout::GeometryTrianglesNV( rhs )
+ {}
GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
+ layout::GeometryTrianglesNV::operator=(rhs);
return *this;
}
@@ -17023,13 +19360,13 @@
return *this;
}
- GeometryTrianglesNV & setVertexData( Buffer vertexData_ )
+ GeometryTrianglesNV & setVertexData( vk::Buffer vertexData_ )
{
vertexData = vertexData_;
return *this;
}
- GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ )
+ GeometryTrianglesNV & setVertexOffset( vk::DeviceSize vertexOffset_ )
{
vertexOffset = vertexOffset_;
return *this;
@@ -17041,25 +19378,25 @@
return *this;
}
- GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ )
+ GeometryTrianglesNV & setVertexStride( vk::DeviceSize vertexStride_ )
{
vertexStride = vertexStride_;
return *this;
}
- GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ )
+ GeometryTrianglesNV & setVertexFormat( vk::Format vertexFormat_ )
{
vertexFormat = vertexFormat_;
return *this;
}
- GeometryTrianglesNV & setIndexData( Buffer indexData_ )
+ GeometryTrianglesNV & setIndexData( vk::Buffer indexData_ )
{
indexData = indexData_;
return *this;
}
- GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ )
+ GeometryTrianglesNV & setIndexOffset( vk::DeviceSize indexOffset_ )
{
indexOffset = indexOffset_;
return *this;
@@ -17071,19 +19408,19 @@
return *this;
}
- GeometryTrianglesNV & setIndexType( IndexType indexType_ )
+ GeometryTrianglesNV & setIndexType( vk::IndexType indexType_ )
{
indexType = indexType_;
return *this;
}
- GeometryTrianglesNV & setTransformData( Buffer transformData_ )
+ GeometryTrianglesNV & setTransformData( vk::Buffer transformData_ )
{
transformData = transformData_;
return *this;
}
- GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ )
+ GeometryTrianglesNV & setTransformOffset( vk::DeviceSize transformOffset_ )
{
transformOffset = transformOffset_;
return *this;
@@ -17122,44 +19459,64 @@
}
private:
- StructureType sType = StructureType::eGeometryTrianglesNV;
-
- public:
- const void* pNext = nullptr;
- Buffer vertexData;
- DeviceSize vertexOffset;
- uint32_t vertexCount;
- DeviceSize vertexStride;
- Format vertexFormat;
- Buffer indexData;
- DeviceSize indexOffset;
- uint32_t indexCount;
- IndexType indexType;
- Buffer transformData;
- DeviceSize transformOffset;
+ using layout::GeometryTrianglesNV::sType;
};
static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<GeometryTrianglesNV>::value, "struct wrapper is not a standard layout!" );
- struct GeometryAABBNV
+ namespace layout
{
- GeometryAABBNV( Buffer aabbData_ = Buffer(),
- uint32_t numAABBs_ = 0,
- uint32_t stride_ = 0,
- DeviceSize offset_ = 0 )
- : aabbData( aabbData_ )
- , numAABBs( numAABBs_ )
- , stride( stride_ )
- , offset( offset_ )
+ struct GeometryAABBNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(),
+ uint32_t numAABBs_ = 0,
+ uint32_t stride_ = 0,
+ vk::DeviceSize offset_ = 0 )
+ : aabbData( aabbData_ )
+ , numAABBs( numAABBs_ )
+ , stride( stride_ )
+ , offset( offset_ )
+ {}
+
+ GeometryAABBNV( VkGeometryAABBNV const & rhs )
+ {
+ *reinterpret_cast<VkGeometryAABBNV*>(this) = rhs;
+ }
+
+ GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
+ {
+ *reinterpret_cast<VkGeometryAABBNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eGeometryAabbNV;
+ const void* pNext = nullptr;
+ vk::Buffer aabbData;
+ uint32_t numAABBs;
+ uint32_t stride;
+ vk::DeviceSize offset;
+ };
+ static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct GeometryAABBNV : public layout::GeometryAABBNV
+ {
+ VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(),
+ uint32_t numAABBs_ = 0,
+ uint32_t stride_ = 0,
+ vk::DeviceSize offset_ = 0 )
+ : layout::GeometryAABBNV( aabbData_, numAABBs_, stride_, offset_ )
{}
GeometryAABBNV( VkGeometryAABBNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
- }
+ : layout::GeometryAABBNV( rhs )
+ {}
GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs )
{
- memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
+ layout::GeometryAABBNV::operator=(rhs);
return *this;
}
@@ -17169,7 +19526,7 @@
return *this;
}
- GeometryAABBNV & setAabbData( Buffer aabbData_ )
+ GeometryAABBNV & setAabbData( vk::Buffer aabbData_ )
{
aabbData = aabbData_;
return *this;
@@ -17187,7 +19544,7 @@
return *this;
}
- GeometryAABBNV & setOffset( DeviceSize offset_ )
+ GeometryAABBNV & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
@@ -17219,43 +19576,37 @@
}
private:
- StructureType sType = StructureType::eGeometryAabbNV;
-
- public:
- const void* pNext = nullptr;
- Buffer aabbData;
- uint32_t numAABBs;
- uint32_t stride;
- DeviceSize offset;
+ using layout::GeometryAABBNV::sType;
};
static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<GeometryAABBNV>::value, "struct wrapper is not a standard layout!" );
struct GeometryDataNV
{
- GeometryDataNV( GeometryTrianglesNV triangles_ = GeometryTrianglesNV(),
- GeometryAABBNV aabbs_ = GeometryAABBNV() )
+ VULKAN_HPP_CONSTEXPR GeometryDataNV( vk::GeometryTrianglesNV triangles_ = vk::GeometryTrianglesNV(),
+ vk::GeometryAABBNV aabbs_ = vk::GeometryAABBNV() )
: triangles( triangles_ )
, aabbs( aabbs_ )
{}
GeometryDataNV( VkGeometryDataNV const & rhs )
{
- memcpy( this, &rhs, sizeof( GeometryDataNV ) );
+ *reinterpret_cast<VkGeometryDataNV*>(this) = rhs;
}
GeometryDataNV& operator=( VkGeometryDataNV const & rhs )
{
- memcpy( this, &rhs, sizeof( GeometryDataNV ) );
+ *reinterpret_cast<VkGeometryDataNV*>(this) = rhs;
return *this;
}
- GeometryDataNV & setTriangles( GeometryTrianglesNV triangles_ )
+ GeometryDataNV & setTriangles( vk::GeometryTrianglesNV triangles_ )
{
triangles = triangles_;
return *this;
}
- GeometryDataNV & setAabbs( GeometryAABBNV aabbs_ )
+ GeometryDataNV & setAabbs( vk::GeometryAABBNV aabbs_ )
{
aabbs = aabbs_;
return *this;
@@ -17282,29 +19633,62 @@
return !operator==( rhs );
}
- GeometryTrianglesNV triangles;
- GeometryAABBNV aabbs;
+ public:
+ vk::GeometryTrianglesNV triangles;
+ vk::GeometryAABBNV aabbs;
};
static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<GeometryDataNV>::value, "struct wrapper is not a standard layout!" );
- struct GeometryNV
+ namespace layout
{
- GeometryNV( GeometryTypeNV geometryType_ = GeometryTypeNV::eTriangles,
- GeometryDataNV geometry_ = GeometryDataNV(),
- GeometryFlagsNV flags_ = GeometryFlagsNV() )
- : geometryType( geometryType_ )
- , geometry( geometry_ )
- , flags( flags_ )
+ struct GeometryNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles,
+ vk::GeometryDataNV geometry_ = vk::GeometryDataNV(),
+ vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() )
+ : geometryType( geometryType_ )
+ , geometry( geometry_ )
+ , flags( flags_ )
+ {}
+
+ GeometryNV( VkGeometryNV const & rhs )
+ {
+ *reinterpret_cast<VkGeometryNV*>(this) = rhs;
+ }
+
+ GeometryNV& operator=( VkGeometryNV const & rhs )
+ {
+ *reinterpret_cast<VkGeometryNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eGeometryNV;
+ const void* pNext = nullptr;
+ vk::GeometryTypeNV geometryType;
+ vk::GeometryDataNV geometry;
+ vk::GeometryFlagsNV flags;
+ };
+ static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct GeometryNV : public layout::GeometryNV
+ {
+ VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles,
+ vk::GeometryDataNV geometry_ = vk::GeometryDataNV(),
+ vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() )
+ : layout::GeometryNV( geometryType_, geometry_, flags_ )
{}
GeometryNV( VkGeometryNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( GeometryNV ) );
- }
+ : layout::GeometryNV( rhs )
+ {}
GeometryNV& operator=( VkGeometryNV const & rhs )
{
- memcpy( this, &rhs, sizeof( GeometryNV ) );
+ layout::GeometryNV::operator=(rhs);
return *this;
}
@@ -17314,19 +19698,19 @@
return *this;
}
- GeometryNV & setGeometryType( GeometryTypeNV geometryType_ )
+ GeometryNV & setGeometryType( vk::GeometryTypeNV geometryType_ )
{
geometryType = geometryType_;
return *this;
}
- GeometryNV & setGeometry( GeometryDataNV geometry_ )
+ GeometryNV & setGeometry( vk::GeometryDataNV geometry_ )
{
geometry = geometry_;
return *this;
}
- GeometryNV & setFlags( GeometryFlagsNV flags_ )
+ GeometryNV & setFlags( vk::GeometryFlagsNV flags_ )
{
flags = flags_;
return *this;
@@ -17357,38 +19741,68 @@
}
private:
- StructureType sType = StructureType::eGeometryNV;
-
- public:
- const void* pNext = nullptr;
- GeometryTypeNV geometryType;
- GeometryDataNV geometry;
- GeometryFlagsNV flags;
+ using layout::GeometryNV::sType;
};
static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<GeometryNV>::value, "struct wrapper is not a standard layout!" );
- struct AccelerationStructureInfoNV
+ namespace layout
{
- AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = AccelerationStructureTypeNV::eTopLevel,
- BuildAccelerationStructureFlagsNV flags_ = BuildAccelerationStructureFlagsNV(),
- uint32_t instanceCount_ = 0,
- uint32_t geometryCount_ = 0,
- const GeometryNV* pGeometries_ = nullptr )
- : type( type_ )
- , flags( flags_ )
- , instanceCount( instanceCount_ )
- , geometryCount( geometryCount_ )
- , pGeometries( pGeometries_ )
+ struct AccelerationStructureInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel,
+ vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(),
+ uint32_t instanceCount_ = 0,
+ uint32_t geometryCount_ = 0,
+ const vk::GeometryNV* pGeometries_ = nullptr )
+ : type( type_ )
+ , flags( flags_ )
+ , instanceCount( instanceCount_ )
+ , geometryCount( geometryCount_ )
+ , pGeometries( pGeometries_ )
+ {}
+
+ AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkAccelerationStructureInfoNV*>(this) = rhs;
+ }
+
+ AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkAccelerationStructureInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAccelerationStructureInfoNV;
+ const void* pNext = nullptr;
+ vk::AccelerationStructureTypeNV type;
+ vk::BuildAccelerationStructureFlagsNV flags;
+ uint32_t instanceCount;
+ uint32_t geometryCount;
+ const vk::GeometryNV* pGeometries;
+ };
+ static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AccelerationStructureInfoNV : public layout::AccelerationStructureInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel,
+ vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(),
+ uint32_t instanceCount_ = 0,
+ uint32_t geometryCount_ = 0,
+ const vk::GeometryNV* pGeometries_ = nullptr )
+ : layout::AccelerationStructureInfoNV( type_, flags_, instanceCount_, geometryCount_, pGeometries_ )
{}
AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
- }
+ : layout::AccelerationStructureInfoNV( rhs )
+ {}
AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
+ layout::AccelerationStructureInfoNV::operator=(rhs);
return *this;
}
@@ -17398,13 +19812,13 @@
return *this;
}
- AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ )
+ AccelerationStructureInfoNV & setType( vk::AccelerationStructureTypeNV type_ )
{
type = type_;
return *this;
}
- AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsNV flags_ )
+ AccelerationStructureInfoNV & setFlags( vk::BuildAccelerationStructureFlagsNV flags_ )
{
flags = flags_;
return *this;
@@ -17422,7 +19836,7 @@
return *this;
}
- AccelerationStructureInfoNV & setPGeometries( const GeometryNV* pGeometries_ )
+ AccelerationStructureInfoNV & setPGeometries( const vk::GeometryNV* pGeometries_ )
{
pGeometries = pGeometries_;
return *this;
@@ -17455,34 +19869,56 @@
}
private:
- StructureType sType = StructureType::eAccelerationStructureInfoNV;
-
- public:
- const void* pNext = nullptr;
- AccelerationStructureTypeNV type;
- BuildAccelerationStructureFlagsNV flags;
- uint32_t instanceCount;
- uint32_t geometryCount;
- const GeometryNV* pGeometries;
+ using layout::AccelerationStructureInfoNV::sType;
};
static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AccelerationStructureInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct AccelerationStructureCreateInfoNV
+ namespace layout
{
- AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = 0,
- AccelerationStructureInfoNV info_ = AccelerationStructureInfoNV() )
- : compactedSize( compactedSize_ )
- , info( info_ )
+ struct AccelerationStructureCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0,
+ vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() )
+ : compactedSize( compactedSize_ )
+ , info( info_ )
+ {}
+
+ AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
+ }
+
+ AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::DeviceSize compactedSize;
+ vk::AccelerationStructureInfoNV info;
+ };
+ static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AccelerationStructureCreateInfoNV : public layout::AccelerationStructureCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0,
+ vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() )
+ : layout::AccelerationStructureCreateInfoNV( compactedSize_, info_ )
{}
AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
- }
+ : layout::AccelerationStructureCreateInfoNV( rhs )
+ {}
AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
+ layout::AccelerationStructureCreateInfoNV::operator=(rhs);
return *this;
}
@@ -17492,13 +19928,13 @@
return *this;
}
- AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ )
+ AccelerationStructureCreateInfoNV & setCompactedSize( vk::DeviceSize compactedSize_ )
{
compactedSize = compactedSize_;
return *this;
}
- AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV info_ )
+ AccelerationStructureCreateInfoNV & setInfo( vk::AccelerationStructureInfoNV info_ )
{
info = info_;
return *this;
@@ -17528,31 +19964,56 @@
}
private:
- StructureType sType = StructureType::eAccelerationStructureCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- DeviceSize compactedSize;
- AccelerationStructureInfoNV info;
+ using layout::AccelerationStructureCreateInfoNV::sType;
};
static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AccelerationStructureCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct AccelerationStructureMemoryRequirementsInfoNV
+ namespace layout
{
- AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject,
- AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() )
- : type( type_ )
- , accelerationStructure( accelerationStructure_ )
+ struct AccelerationStructureMemoryRequirementsInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject,
+ vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() )
+ : type( type_ )
+ , accelerationStructure( accelerationStructure_ )
+ {}
+
+ AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
+ }
+
+ AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
+ const void* pNext = nullptr;
+ vk::AccelerationStructureMemoryRequirementsTypeNV type;
+ vk::AccelerationStructureNV accelerationStructure;
+ };
+ static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AccelerationStructureMemoryRequirementsInfoNV : public layout::AccelerationStructureMemoryRequirementsInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject,
+ vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() )
+ : layout::AccelerationStructureMemoryRequirementsInfoNV( type_, accelerationStructure_ )
{}
AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
- }
+ : layout::AccelerationStructureMemoryRequirementsInfoNV( rhs )
+ {}
AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( AccelerationStructureMemoryRequirementsInfoNV ) );
+ layout::AccelerationStructureMemoryRequirementsInfoNV::operator=(rhs);
return *this;
}
@@ -17562,13 +20023,13 @@
return *this;
}
- AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ )
+ AccelerationStructureMemoryRequirementsInfoNV & setType( vk::AccelerationStructureMemoryRequirementsTypeNV type_ )
{
type = type_;
return *this;
}
- AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+ AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( vk::AccelerationStructureNV accelerationStructure_ )
{
accelerationStructure = accelerationStructure_;
return *this;
@@ -17598,37 +20059,68 @@
}
private:
- StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV;
-
- public:
- const void* pNext = nullptr;
- AccelerationStructureMemoryRequirementsTypeNV type;
- AccelerationStructureNV accelerationStructure;
+ using layout::AccelerationStructureMemoryRequirementsInfoNV::sType;
};
static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AccelerationStructureMemoryRequirementsInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct AcquireNextImageInfoKHR
+ namespace layout
{
- AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
- uint64_t timeout_ = 0,
- Semaphore semaphore_ = Semaphore(),
- Fence fence_ = Fence(),
- uint32_t deviceMask_ = 0 )
- : swapchain( swapchain_ )
- , timeout( timeout_ )
- , semaphore( semaphore_ )
- , fence( fence_ )
- , deviceMask( deviceMask_ )
+ struct AcquireNextImageInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
+ uint64_t timeout_ = 0,
+ vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::Fence fence_ = vk::Fence(),
+ uint32_t deviceMask_ = 0 )
+ : swapchain( swapchain_ )
+ , timeout( timeout_ )
+ , semaphore( semaphore_ )
+ , fence( fence_ )
+ , deviceMask( deviceMask_ )
+ {}
+
+ AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
+ }
+
+ AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAcquireNextImageInfoKHR;
+ const void* pNext = nullptr;
+ vk::SwapchainKHR swapchain;
+ uint64_t timeout;
+ vk::Semaphore semaphore;
+ vk::Fence fence;
+ uint32_t deviceMask;
+ };
+ static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AcquireNextImageInfoKHR : public layout::AcquireNextImageInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
+ uint64_t timeout_ = 0,
+ vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::Fence fence_ = vk::Fence(),
+ uint32_t deviceMask_ = 0 )
+ : layout::AcquireNextImageInfoKHR( swapchain_, timeout_, semaphore_, fence_, deviceMask_ )
{}
AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
- }
+ : layout::AcquireNextImageInfoKHR( rhs )
+ {}
AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
+ layout::AcquireNextImageInfoKHR::operator=(rhs);
return *this;
}
@@ -17638,7 +20130,7 @@
return *this;
}
- AcquireNextImageInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+ AcquireNextImageInfoKHR & setSwapchain( vk::SwapchainKHR swapchain_ )
{
swapchain = swapchain_;
return *this;
@@ -17650,13 +20142,13 @@
return *this;
}
- AcquireNextImageInfoKHR & setSemaphore( Semaphore semaphore_ )
+ AcquireNextImageInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
{
semaphore = semaphore_;
return *this;
}
- AcquireNextImageInfoKHR & setFence( Fence fence_ )
+ AcquireNextImageInfoKHR & setFence( vk::Fence fence_ )
{
fence = fence_;
return *this;
@@ -17695,26 +20187,19 @@
}
private:
- StructureType sType = StructureType::eAcquireNextImageInfoKHR;
-
- public:
- const void* pNext = nullptr;
- SwapchainKHR swapchain;
- uint64_t timeout;
- Semaphore semaphore;
- Fence fence;
- uint32_t deviceMask;
+ using layout::AcquireNextImageInfoKHR::sType;
};
static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AcquireNextImageInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct AllocationCallbacks
{
- AllocationCallbacks( void* pUserData_ = nullptr,
- PFN_vkAllocationFunction pfnAllocation_ = nullptr,
- PFN_vkReallocationFunction pfnReallocation_ = nullptr,
- PFN_vkFreeFunction pfnFree_ = nullptr,
- PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
- PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
+ VULKAN_HPP_CONSTEXPR AllocationCallbacks( void* pUserData_ = nullptr,
+ PFN_vkAllocationFunction pfnAllocation_ = nullptr,
+ PFN_vkReallocationFunction pfnReallocation_ = nullptr,
+ PFN_vkFreeFunction pfnFree_ = nullptr,
+ PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
+ PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
: pUserData( pUserData_ )
, pfnAllocation( pfnAllocation_ )
, pfnReallocation( pfnReallocation_ )
@@ -17725,12 +20210,12 @@
AllocationCallbacks( VkAllocationCallbacks const & rhs )
{
- memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
+ *reinterpret_cast<VkAllocationCallbacks*>(this) = rhs;
}
AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
{
- memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
+ *reinterpret_cast<VkAllocationCallbacks*>(this) = rhs;
return *this;
}
@@ -17795,6 +20280,7 @@
return !operator==( rhs );
}
+ public:
void* pUserData;
PFN_vkAllocationFunction pfnAllocation;
PFN_vkReallocationFunction pfnReallocation;
@@ -17803,13 +20289,14 @@
PFN_vkInternalFreeNotification pfnInternalFree;
};
static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AllocationCallbacks>::value, "struct wrapper is not a standard layout!" );
struct ComponentMapping
{
- ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity,
- ComponentSwizzle g_ = ComponentSwizzle::eIdentity,
- ComponentSwizzle b_ = ComponentSwizzle::eIdentity,
- ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
+ VULKAN_HPP_CONSTEXPR ComponentMapping( vk::ComponentSwizzle r_ = vk::ComponentSwizzle::eIdentity,
+ vk::ComponentSwizzle g_ = vk::ComponentSwizzle::eIdentity,
+ vk::ComponentSwizzle b_ = vk::ComponentSwizzle::eIdentity,
+ vk::ComponentSwizzle a_ = vk::ComponentSwizzle::eIdentity )
: r( r_ )
, g( g_ )
, b( b_ )
@@ -17818,34 +20305,34 @@
ComponentMapping( VkComponentMapping const & rhs )
{
- memcpy( this, &rhs, sizeof( ComponentMapping ) );
+ *reinterpret_cast<VkComponentMapping*>(this) = rhs;
}
ComponentMapping& operator=( VkComponentMapping const & rhs )
{
- memcpy( this, &rhs, sizeof( ComponentMapping ) );
+ *reinterpret_cast<VkComponentMapping*>(this) = rhs;
return *this;
}
- ComponentMapping & setR( ComponentSwizzle r_ )
+ ComponentMapping & setR( vk::ComponentSwizzle r_ )
{
r = r_;
return *this;
}
- ComponentMapping & setG( ComponentSwizzle g_ )
+ ComponentMapping & setG( vk::ComponentSwizzle g_ )
{
g = g_;
return *this;
}
- ComponentMapping & setB( ComponentSwizzle b_ )
+ ComponentMapping & setB( vk::ComponentSwizzle b_ )
{
b = b_;
return *this;
}
- ComponentMapping & setA( ComponentSwizzle a_ )
+ ComponentMapping & setA( vk::ComponentSwizzle a_ )
{
a = a_;
return *this;
@@ -17874,16 +20361,67 @@
return !operator==( rhs );
}
- ComponentSwizzle r;
- ComponentSwizzle g;
- ComponentSwizzle b;
- ComponentSwizzle a;
+ public:
+ vk::ComponentSwizzle r;
+ vk::ComponentSwizzle g;
+ vk::ComponentSwizzle b;
+ vk::ComponentSwizzle a;
};
static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ComponentMapping>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct AndroidHardwareBufferFormatPropertiesANDROID
+
+ namespace layout
{
+ struct AndroidHardwareBufferFormatPropertiesANDROID
+ {
+ protected:
+ AndroidHardwareBufferFormatPropertiesANDROID()
+ {}
+
+ AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs )
+ {
+ *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this) = rhs;
+ }
+
+ AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs )
+ {
+ *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
+ void* pNext = nullptr;
+ vk::Format format;
+ uint64_t externalFormat;
+ vk::FormatFeatureFlags formatFeatures;
+ vk::ComponentMapping samplerYcbcrConversionComponents;
+ vk::SamplerYcbcrModelConversion suggestedYcbcrModel;
+ vk::SamplerYcbcrRange suggestedYcbcrRange;
+ vk::ChromaLocation suggestedXChromaOffset;
+ vk::ChromaLocation suggestedYChromaOffset;
+ };
+ static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AndroidHardwareBufferFormatPropertiesANDROID : public layout::AndroidHardwareBufferFormatPropertiesANDROID
+ {
+ AndroidHardwareBufferFormatPropertiesANDROID()
+ : layout::AndroidHardwareBufferFormatPropertiesANDROID()
+ {}
+
+ AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs )
+ : layout::AndroidHardwareBufferFormatPropertiesANDROID( rhs )
+ {}
+
+ AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs )
+ {
+ layout::AndroidHardwareBufferFormatPropertiesANDROID::operator=(rhs);
+ return *this;
+ }
+
operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const
{
return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>( this );
@@ -17914,25 +20452,58 @@
}
private:
- StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID;
-
- public:
- void* pNext = nullptr;
- Format format;
- uint64_t externalFormat;
- FormatFeatureFlags formatFeatures;
- ComponentMapping samplerYcbcrConversionComponents;
- SamplerYcbcrModelConversion suggestedYcbcrModel;
- SamplerYcbcrRange suggestedYcbcrRange;
- ChromaLocation suggestedXChromaOffset;
- ChromaLocation suggestedYChromaOffset;
+ using layout::AndroidHardwareBufferFormatPropertiesANDROID::sType;
};
static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AndroidHardwareBufferFormatPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct AndroidHardwareBufferPropertiesANDROID
+
+ namespace layout
{
+ struct AndroidHardwareBufferPropertiesANDROID
+ {
+ protected:
+ AndroidHardwareBufferPropertiesANDROID()
+ {}
+
+ AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs )
+ {
+ *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this) = rhs;
+ }
+
+ AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs )
+ {
+ *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
+ void* pNext = nullptr;
+ vk::DeviceSize allocationSize;
+ uint32_t memoryTypeBits;
+ };
+ static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AndroidHardwareBufferPropertiesANDROID : public layout::AndroidHardwareBufferPropertiesANDROID
+ {
+ AndroidHardwareBufferPropertiesANDROID()
+ : layout::AndroidHardwareBufferPropertiesANDROID()
+ {}
+
+ AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs )
+ : layout::AndroidHardwareBufferPropertiesANDROID( rhs )
+ {}
+
+ AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs )
+ {
+ layout::AndroidHardwareBufferPropertiesANDROID::operator=(rhs);
+ return *this;
+ }
+
operator VkAndroidHardwareBufferPropertiesANDROID const&() const
{
return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>( this );
@@ -17957,19 +20528,57 @@
}
private:
- StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID;
-
- public:
- void* pNext = nullptr;
- DeviceSize allocationSize;
- uint32_t memoryTypeBits;
+ using layout::AndroidHardwareBufferPropertiesANDROID::sType;
};
static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AndroidHardwareBufferPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct AndroidHardwareBufferUsageANDROID
+
+ namespace layout
{
+ struct AndroidHardwareBufferUsageANDROID
+ {
+ protected:
+ AndroidHardwareBufferUsageANDROID()
+ {}
+
+ AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs )
+ {
+ *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this) = rhs;
+ }
+
+ AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs )
+ {
+ *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
+ void* pNext = nullptr;
+ uint64_t androidHardwareBufferUsage;
+ };
+ static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AndroidHardwareBufferUsageANDROID : public layout::AndroidHardwareBufferUsageANDROID
+ {
+ AndroidHardwareBufferUsageANDROID()
+ : layout::AndroidHardwareBufferUsageANDROID()
+ {}
+
+ AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs )
+ : layout::AndroidHardwareBufferUsageANDROID( rhs )
+ {}
+
+ AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs )
+ {
+ layout::AndroidHardwareBufferUsageANDROID::operator=(rhs);
+ return *this;
+ }
+
operator VkAndroidHardwareBufferUsageANDROID const&() const
{
return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>( this );
@@ -17993,32 +20602,59 @@
}
private:
- StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID;
-
- public:
- void* pNext = nullptr;
- uint64_t androidHardwareBufferUsage;
+ using layout::AndroidHardwareBufferUsageANDROID::sType;
};
static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AndroidHardwareBufferUsageANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct AndroidSurfaceCreateInfoKHR
+
+ namespace layout
{
- AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(),
- struct ANativeWindow* window_ = nullptr )
- : flags( flags_ )
- , window( window_ )
+ struct AndroidSurfaceCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(),
+ struct ANativeWindow* window_ = nullptr )
+ : flags( flags_ )
+ , window( window_ )
+ {}
+
+ AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
+ }
+
+ AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::AndroidSurfaceCreateFlagsKHR flags;
+ struct ANativeWindow* window;
+ };
+ static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AndroidSurfaceCreateInfoKHR : public layout::AndroidSurfaceCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(),
+ struct ANativeWindow* window_ = nullptr )
+ : layout::AndroidSurfaceCreateInfoKHR( flags_, window_ )
{}
AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
- }
+ : layout::AndroidSurfaceCreateInfoKHR( rhs )
+ {}
AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
+ layout::AndroidSurfaceCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -18028,7 +20664,7 @@
return *this;
}
- AndroidSurfaceCreateInfoKHR & setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
+ AndroidSurfaceCreateInfoKHR & setFlags( vk::AndroidSurfaceCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
@@ -18064,38 +20700,69 @@
}
private:
- StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- AndroidSurfaceCreateFlagsKHR flags;
- struct ANativeWindow* window;
+ using layout::AndroidSurfaceCreateInfoKHR::sType;
};
static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AndroidSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- struct ApplicationInfo
+ namespace layout
{
- ApplicationInfo( const char* pApplicationName_ = nullptr,
- uint32_t applicationVersion_ = 0,
- const char* pEngineName_ = nullptr,
- uint32_t engineVersion_ = 0,
- uint32_t apiVersion_ = 0 )
- : pApplicationName( pApplicationName_ )
- , applicationVersion( applicationVersion_ )
- , pEngineName( pEngineName_ )
- , engineVersion( engineVersion_ )
- , apiVersion( apiVersion_ )
+ struct ApplicationInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr,
+ uint32_t applicationVersion_ = 0,
+ const char* pEngineName_ = nullptr,
+ uint32_t engineVersion_ = 0,
+ uint32_t apiVersion_ = 0 )
+ : pApplicationName( pApplicationName_ )
+ , applicationVersion( applicationVersion_ )
+ , pEngineName( pEngineName_ )
+ , engineVersion( engineVersion_ )
+ , apiVersion( apiVersion_ )
+ {}
+
+ ApplicationInfo( VkApplicationInfo const & rhs )
+ {
+ *reinterpret_cast<VkApplicationInfo*>(this) = rhs;
+ }
+
+ ApplicationInfo& operator=( VkApplicationInfo const & rhs )
+ {
+ *reinterpret_cast<VkApplicationInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eApplicationInfo;
+ const void* pNext = nullptr;
+ const char* pApplicationName;
+ uint32_t applicationVersion;
+ const char* pEngineName;
+ uint32_t engineVersion;
+ uint32_t apiVersion;
+ };
+ static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ApplicationInfo : public layout::ApplicationInfo
+ {
+ VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr,
+ uint32_t applicationVersion_ = 0,
+ const char* pEngineName_ = nullptr,
+ uint32_t engineVersion_ = 0,
+ uint32_t apiVersion_ = 0 )
+ : layout::ApplicationInfo( pApplicationName_, applicationVersion_, pEngineName_, engineVersion_, apiVersion_ )
{}
ApplicationInfo( VkApplicationInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ApplicationInfo ) );
- }
+ : layout::ApplicationInfo( rhs )
+ {}
ApplicationInfo& operator=( VkApplicationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ApplicationInfo ) );
+ layout::ApplicationInfo::operator=(rhs);
return *this;
}
@@ -18162,29 +20829,22 @@
}
private:
- StructureType sType = StructureType::eApplicationInfo;
-
- public:
- const void* pNext = nullptr;
- const char* pApplicationName;
- uint32_t applicationVersion;
- const char* pEngineName;
- uint32_t engineVersion;
- uint32_t apiVersion;
+ using layout::ApplicationInfo::sType;
};
static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ApplicationInfo>::value, "struct wrapper is not a standard layout!" );
struct AttachmentDescription
{
- 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 )
+ VULKAN_HPP_CONSTEXPR AttachmentDescription( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad,
+ vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore,
+ vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad,
+ vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
+ vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
+ vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined )
: flags( flags_ )
, format( format_ )
, samples( samples_ )
@@ -18198,64 +20858,64 @@
AttachmentDescription( VkAttachmentDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentDescription ) );
+ *reinterpret_cast<VkAttachmentDescription*>(this) = rhs;
}
AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentDescription ) );
+ *reinterpret_cast<VkAttachmentDescription*>(this) = rhs;
return *this;
}
- AttachmentDescription & setFlags( AttachmentDescriptionFlags flags_ )
+ AttachmentDescription & setFlags( vk::AttachmentDescriptionFlags flags_ )
{
flags = flags_;
return *this;
}
- AttachmentDescription & setFormat( Format format_ )
+ AttachmentDescription & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- AttachmentDescription & setSamples( SampleCountFlagBits samples_ )
+ AttachmentDescription & setSamples( vk::SampleCountFlagBits samples_ )
{
samples = samples_;
return *this;
}
- AttachmentDescription & setLoadOp( AttachmentLoadOp loadOp_ )
+ AttachmentDescription & setLoadOp( vk::AttachmentLoadOp loadOp_ )
{
loadOp = loadOp_;
return *this;
}
- AttachmentDescription & setStoreOp( AttachmentStoreOp storeOp_ )
+ AttachmentDescription & setStoreOp( vk::AttachmentStoreOp storeOp_ )
{
storeOp = storeOp_;
return *this;
}
- AttachmentDescription & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ AttachmentDescription & setStencilLoadOp( vk::AttachmentLoadOp stencilLoadOp_ )
{
stencilLoadOp = stencilLoadOp_;
return *this;
}
- AttachmentDescription & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ AttachmentDescription & setStencilStoreOp( vk::AttachmentStoreOp stencilStoreOp_ )
{
stencilStoreOp = stencilStoreOp_;
return *this;
}
- AttachmentDescription & setInitialLayout( ImageLayout initialLayout_ )
+ AttachmentDescription & setInitialLayout( vk::ImageLayout initialLayout_ )
{
initialLayout = initialLayout_;
return *this;
}
- AttachmentDescription & setFinalLayout( ImageLayout finalLayout_ )
+ AttachmentDescription & setFinalLayout( vk::ImageLayout finalLayout_ )
{
finalLayout = finalLayout_;
return *this;
@@ -18289,48 +20949,93 @@
return !operator==( rhs );
}
- AttachmentDescriptionFlags flags;
- Format format;
- SampleCountFlagBits samples;
- AttachmentLoadOp loadOp;
- AttachmentStoreOp storeOp;
- AttachmentLoadOp stencilLoadOp;
- AttachmentStoreOp stencilStoreOp;
- ImageLayout initialLayout;
- ImageLayout finalLayout;
+ public:
+ vk::AttachmentDescriptionFlags flags;
+ vk::Format format;
+ vk::SampleCountFlagBits samples;
+ vk::AttachmentLoadOp loadOp;
+ vk::AttachmentStoreOp storeOp;
+ vk::AttachmentLoadOp stencilLoadOp;
+ vk::AttachmentStoreOp stencilStoreOp;
+ vk::ImageLayout initialLayout;
+ vk::ImageLayout finalLayout;
};
static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AttachmentDescription>::value, "struct wrapper is not a standard layout!" );
- struct AttachmentDescription2KHR
+ namespace layout
{
- AttachmentDescription2KHR( 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 )
- : flags( flags_ )
- , format( format_ )
- , samples( samples_ )
- , loadOp( loadOp_ )
- , storeOp( storeOp_ )
- , stencilLoadOp( stencilLoadOp_ )
- , stencilStoreOp( stencilStoreOp_ )
- , initialLayout( initialLayout_ )
- , finalLayout( finalLayout_ )
+ struct AttachmentDescription2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad,
+ vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore,
+ vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad,
+ vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
+ vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
+ vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined )
+ : flags( flags_ )
+ , format( format_ )
+ , samples( samples_ )
+ , loadOp( loadOp_ )
+ , storeOp( storeOp_ )
+ , stencilLoadOp( stencilLoadOp_ )
+ , stencilStoreOp( stencilStoreOp_ )
+ , initialLayout( initialLayout_ )
+ , finalLayout( finalLayout_ )
+ {}
+
+ AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
+ {
+ *reinterpret_cast<VkAttachmentDescription2KHR*>(this) = rhs;
+ }
+
+ AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
+ {
+ *reinterpret_cast<VkAttachmentDescription2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAttachmentDescription2KHR;
+ const void* pNext = nullptr;
+ vk::AttachmentDescriptionFlags flags;
+ vk::Format format;
+ vk::SampleCountFlagBits samples;
+ vk::AttachmentLoadOp loadOp;
+ vk::AttachmentStoreOp storeOp;
+ vk::AttachmentLoadOp stencilLoadOp;
+ vk::AttachmentStoreOp stencilStoreOp;
+ vk::ImageLayout initialLayout;
+ vk::ImageLayout finalLayout;
+ };
+ static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AttachmentDescription2KHR : public layout::AttachmentDescription2KHR
+ {
+ VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(),
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad,
+ vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore,
+ vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad,
+ vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore,
+ vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined,
+ vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined )
+ : layout::AttachmentDescription2KHR( flags_, format_, samples_, loadOp_, storeOp_, stencilLoadOp_, stencilStoreOp_, initialLayout_, finalLayout_ )
{}
AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
- }
+ : layout::AttachmentDescription2KHR( rhs )
+ {}
AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
+ layout::AttachmentDescription2KHR::operator=(rhs);
return *this;
}
@@ -18340,55 +21045,55 @@
return *this;
}
- AttachmentDescription2KHR & setFlags( AttachmentDescriptionFlags flags_ )
+ AttachmentDescription2KHR & setFlags( vk::AttachmentDescriptionFlags flags_ )
{
flags = flags_;
return *this;
}
- AttachmentDescription2KHR & setFormat( Format format_ )
+ AttachmentDescription2KHR & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- AttachmentDescription2KHR & setSamples( SampleCountFlagBits samples_ )
+ AttachmentDescription2KHR & setSamples( vk::SampleCountFlagBits samples_ )
{
samples = samples_;
return *this;
}
- AttachmentDescription2KHR & setLoadOp( AttachmentLoadOp loadOp_ )
+ AttachmentDescription2KHR & setLoadOp( vk::AttachmentLoadOp loadOp_ )
{
loadOp = loadOp_;
return *this;
}
- AttachmentDescription2KHR & setStoreOp( AttachmentStoreOp storeOp_ )
+ AttachmentDescription2KHR & setStoreOp( vk::AttachmentStoreOp storeOp_ )
{
storeOp = storeOp_;
return *this;
}
- AttachmentDescription2KHR & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
+ AttachmentDescription2KHR & setStencilLoadOp( vk::AttachmentLoadOp stencilLoadOp_ )
{
stencilLoadOp = stencilLoadOp_;
return *this;
}
- AttachmentDescription2KHR & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
+ AttachmentDescription2KHR & setStencilStoreOp( vk::AttachmentStoreOp stencilStoreOp_ )
{
stencilStoreOp = stencilStoreOp_;
return *this;
}
- AttachmentDescription2KHR & setInitialLayout( ImageLayout initialLayout_ )
+ AttachmentDescription2KHR & setInitialLayout( vk::ImageLayout initialLayout_ )
{
initialLayout = initialLayout_;
return *this;
}
- AttachmentDescription2KHR & setFinalLayout( ImageLayout finalLayout_ )
+ AttachmentDescription2KHR & setFinalLayout( vk::ImageLayout finalLayout_ )
{
finalLayout = finalLayout_;
return *this;
@@ -18425,38 +21130,27 @@
}
private:
- StructureType sType = StructureType::eAttachmentDescription2KHR;
-
- public:
- const void* pNext = nullptr;
- AttachmentDescriptionFlags flags;
- Format format;
- SampleCountFlagBits samples;
- AttachmentLoadOp loadOp;
- AttachmentStoreOp storeOp;
- AttachmentLoadOp stencilLoadOp;
- AttachmentStoreOp stencilStoreOp;
- ImageLayout initialLayout;
- ImageLayout finalLayout;
+ using layout::AttachmentDescription2KHR::sType;
};
static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AttachmentDescription2KHR>::value, "struct wrapper is not a standard layout!" );
struct AttachmentReference
{
- AttachmentReference( uint32_t attachment_ = 0,
- ImageLayout layout_ = ImageLayout::eUndefined )
+ VULKAN_HPP_CONSTEXPR AttachmentReference( uint32_t attachment_ = 0,
+ vk::ImageLayout layout_ = vk::ImageLayout::eUndefined )
: attachment( attachment_ )
, layout( layout_ )
{}
AttachmentReference( VkAttachmentReference const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentReference ) );
+ *reinterpret_cast<VkAttachmentReference*>(this) = rhs;
}
AttachmentReference& operator=( VkAttachmentReference const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentReference ) );
+ *reinterpret_cast<VkAttachmentReference*>(this) = rhs;
return *this;
}
@@ -18466,7 +21160,7 @@
return *this;
}
- AttachmentReference & setLayout( ImageLayout layout_ )
+ AttachmentReference & setLayout( vk::ImageLayout layout_ )
{
layout = layout_;
return *this;
@@ -18493,29 +21187,62 @@
return !operator==( rhs );
}
+ public:
uint32_t attachment;
- ImageLayout layout;
+ vk::ImageLayout layout;
};
static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AttachmentReference>::value, "struct wrapper is not a standard layout!" );
- struct AttachmentReference2KHR
+ namespace layout
{
- AttachmentReference2KHR( uint32_t attachment_ = 0,
- ImageLayout layout_ = ImageLayout::eUndefined,
- ImageAspectFlags aspectMask_ = ImageAspectFlags() )
- : attachment( attachment_ )
- , layout( layout_ )
- , aspectMask( aspectMask_ )
+ struct AttachmentReference2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0,
+ vk::ImageLayout layout_ = vk::ImageLayout::eUndefined,
+ vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() )
+ : attachment( attachment_ )
+ , layout( layout_ )
+ , aspectMask( aspectMask_ )
+ {}
+
+ AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
+ {
+ *reinterpret_cast<VkAttachmentReference2KHR*>(this) = rhs;
+ }
+
+ AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
+ {
+ *reinterpret_cast<VkAttachmentReference2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eAttachmentReference2KHR;
+ const void* pNext = nullptr;
+ uint32_t attachment;
+ vk::ImageLayout layout;
+ vk::ImageAspectFlags aspectMask;
+ };
+ static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct AttachmentReference2KHR : public layout::AttachmentReference2KHR
+ {
+ VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0,
+ vk::ImageLayout layout_ = vk::ImageLayout::eUndefined,
+ vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() )
+ : layout::AttachmentReference2KHR( attachment_, layout_, aspectMask_ )
{}
AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
- }
+ : layout::AttachmentReference2KHR( rhs )
+ {}
AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
+ layout::AttachmentReference2KHR::operator=(rhs);
return *this;
}
@@ -18531,13 +21258,13 @@
return *this;
}
- AttachmentReference2KHR & setLayout( ImageLayout layout_ )
+ AttachmentReference2KHR & setLayout( vk::ImageLayout layout_ )
{
layout = layout_;
return *this;
}
- AttachmentReference2KHR & setAspectMask( ImageAspectFlags aspectMask_ )
+ AttachmentReference2KHR & setAspectMask( vk::ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
return *this;
@@ -18568,32 +21295,27 @@
}
private:
- StructureType sType = StructureType::eAttachmentReference2KHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t attachment;
- ImageLayout layout;
- ImageAspectFlags aspectMask;
+ using layout::AttachmentReference2KHR::sType;
};
static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AttachmentReference2KHR>::value, "struct wrapper is not a standard layout!" );
struct Extent2D
{
- Extent2D( uint32_t width_ = 0,
- uint32_t height_ = 0 )
+ VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = 0,
+ uint32_t height_ = 0 )
: width( width_ )
, height( height_ )
{}
Extent2D( VkExtent2D const & rhs )
{
- memcpy( this, &rhs, sizeof( Extent2D ) );
+ *reinterpret_cast<VkExtent2D*>(this) = rhs;
}
Extent2D& operator=( VkExtent2D const & rhs )
{
- memcpy( this, &rhs, sizeof( Extent2D ) );
+ *reinterpret_cast<VkExtent2D*>(this) = rhs;
return *this;
}
@@ -18630,27 +21352,29 @@
return !operator==( rhs );
}
+ public:
uint32_t width;
uint32_t height;
};
static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Extent2D>::value, "struct wrapper is not a standard layout!" );
struct SampleLocationEXT
{
- SampleLocationEXT( float x_ = 0,
- float y_ = 0 )
+ VULKAN_HPP_CONSTEXPR SampleLocationEXT( float x_ = 0,
+ float y_ = 0 )
: x( x_ )
, y( y_ )
{}
SampleLocationEXT( VkSampleLocationEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
+ *reinterpret_cast<VkSampleLocationEXT*>(this) = rhs;
}
SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
+ *reinterpret_cast<VkSampleLocationEXT*>(this) = rhs;
return *this;
}
@@ -18687,31 +21411,66 @@
return !operator==( rhs );
}
+ public:
float x;
float y;
};
static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SampleLocationEXT>::value, "struct wrapper is not a standard layout!" );
- struct SampleLocationsInfoEXT
+ namespace layout
{
- SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1,
- Extent2D sampleLocationGridSize_ = Extent2D(),
- uint32_t sampleLocationsCount_ = 0,
- const SampleLocationEXT* pSampleLocations_ = nullptr )
- : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
- , sampleLocationGridSize( sampleLocationGridSize_ )
- , sampleLocationsCount( sampleLocationsCount_ )
- , pSampleLocations( pSampleLocations_ )
+ struct SampleLocationsInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1,
+ vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(),
+ uint32_t sampleLocationsCount_ = 0,
+ const vk::SampleLocationEXT* pSampleLocations_ = nullptr )
+ : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+ , sampleLocationGridSize( sampleLocationGridSize_ )
+ , sampleLocationsCount( sampleLocationsCount_ )
+ , pSampleLocations( pSampleLocations_ )
+ {}
+
+ SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSampleLocationsInfoEXT*>(this) = rhs;
+ }
+
+ SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSampleLocationsInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSampleLocationsInfoEXT;
+ const void* pNext = nullptr;
+ vk::SampleCountFlagBits sampleLocationsPerPixel;
+ vk::Extent2D sampleLocationGridSize;
+ uint32_t sampleLocationsCount;
+ const vk::SampleLocationEXT* pSampleLocations;
+ };
+ static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SampleLocationsInfoEXT : public layout::SampleLocationsInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1,
+ vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(),
+ uint32_t sampleLocationsCount_ = 0,
+ const vk::SampleLocationEXT* pSampleLocations_ = nullptr )
+ : layout::SampleLocationsInfoEXT( sampleLocationsPerPixel_, sampleLocationGridSize_, sampleLocationsCount_, pSampleLocations_ )
{}
SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
- }
+ : layout::SampleLocationsInfoEXT( rhs )
+ {}
SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
+ layout::SampleLocationsInfoEXT::operator=(rhs);
return *this;
}
@@ -18721,13 +21480,13 @@
return *this;
}
- SampleLocationsInfoEXT & setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
+ SampleLocationsInfoEXT & setSampleLocationsPerPixel( vk::SampleCountFlagBits sampleLocationsPerPixel_ )
{
sampleLocationsPerPixel = sampleLocationsPerPixel_;
return *this;
}
- SampleLocationsInfoEXT & setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
+ SampleLocationsInfoEXT & setSampleLocationGridSize( vk::Extent2D sampleLocationGridSize_ )
{
sampleLocationGridSize = sampleLocationGridSize_;
return *this;
@@ -18739,7 +21498,7 @@
return *this;
}
- SampleLocationsInfoEXT & setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
+ SampleLocationsInfoEXT & setPSampleLocations( const vk::SampleLocationEXT* pSampleLocations_ )
{
pSampleLocations = pSampleLocations_;
return *this;
@@ -18771,33 +21530,27 @@
}
private:
- StructureType sType = StructureType::eSampleLocationsInfoEXT;
-
- public:
- const void* pNext = nullptr;
- SampleCountFlagBits sampleLocationsPerPixel;
- Extent2D sampleLocationGridSize;
- uint32_t sampleLocationsCount;
- const SampleLocationEXT* pSampleLocations;
+ using layout::SampleLocationsInfoEXT::sType;
};
static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SampleLocationsInfoEXT>::value, "struct wrapper is not a standard layout!" );
struct AttachmentSampleLocationsEXT
{
- AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
- SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+ VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0,
+ vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
: attachmentIndex( attachmentIndex_ )
, sampleLocationsInfo( sampleLocationsInfo_ )
{}
AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+ *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this) = rhs;
}
AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
+ *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this) = rhs;
return *this;
}
@@ -18807,7 +21560,7 @@
return *this;
}
- AttachmentSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ AttachmentSampleLocationsEXT & setSampleLocationsInfo( vk::SampleLocationsInfoEXT sampleLocationsInfo_ )
{
sampleLocationsInfo = sampleLocationsInfo_;
return *this;
@@ -18834,28 +21587,56 @@
return !operator==( rhs );
}
+ public:
uint32_t attachmentIndex;
- SampleLocationsInfoEXT sampleLocationsInfo;
+ vk::SampleLocationsInfoEXT sampleLocationsInfo;
};
static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<AttachmentSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
- struct BaseInStructure
+ namespace layout
{
- BaseInStructure( )
+ struct BaseInStructure
+ {
+ protected:
+ BaseInStructure()
+ {}
+
+ BaseInStructure( VkBaseInStructure const & rhs )
+ {
+ *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
+ }
+
+ BaseInStructure& operator=( VkBaseInStructure const & rhs )
+ {
+ *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType;
+ const struct vk::BaseInStructure* pNext = nullptr;
+ };
+ static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BaseInStructure : public layout::BaseInStructure
+ {
+ BaseInStructure()
+ : layout::BaseInStructure()
{}
BaseInStructure( VkBaseInStructure const & rhs )
- {
- memcpy( this, &rhs, sizeof( BaseInStructure ) );
- }
+ : layout::BaseInStructure( rhs )
+ {}
BaseInStructure& operator=( VkBaseInStructure const & rhs )
{
- memcpy( this, &rhs, sizeof( BaseInStructure ) );
+ layout::BaseInStructure::operator=(rhs);
return *this;
}
- BaseInStructure & setPNext( const struct BaseInStructure* pNext_ )
+ BaseInStructure & setPNext( const struct vk::BaseInStructure* pNext_ )
{
pNext = pNext_;
return *this;
@@ -18882,28 +21663,55 @@
return !operator==( rhs );
}
- StructureType sType;
- const struct BaseInStructure* pNext = nullptr;
+ private:
+ using layout::BaseInStructure::sType;
};
static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BaseInStructure>::value, "struct wrapper is not a standard layout!" );
- struct BaseOutStructure
+ namespace layout
{
- BaseOutStructure( )
+ struct BaseOutStructure
+ {
+ protected:
+ BaseOutStructure()
+ {}
+
+ BaseOutStructure( VkBaseOutStructure const & rhs )
+ {
+ *reinterpret_cast<VkBaseOutStructure*>(this) = rhs;
+ }
+
+ BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
+ {
+ *reinterpret_cast<VkBaseOutStructure*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType;
+ struct vk::BaseOutStructure* pNext = nullptr;
+ };
+ static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BaseOutStructure : public layout::BaseOutStructure
+ {
+ BaseOutStructure()
+ : layout::BaseOutStructure()
{}
BaseOutStructure( VkBaseOutStructure const & rhs )
- {
- memcpy( this, &rhs, sizeof( BaseOutStructure ) );
- }
+ : layout::BaseOutStructure( rhs )
+ {}
BaseOutStructure& operator=( VkBaseOutStructure const & rhs )
{
- memcpy( this, &rhs, sizeof( BaseOutStructure ) );
+ layout::BaseOutStructure::operator=(rhs);
return *this;
}
- BaseOutStructure & setPNext( struct BaseOutStructure* pNext_ )
+ BaseOutStructure & setPNext( struct vk::BaseOutStructure* pNext_ )
{
pNext = pNext_;
return *this;
@@ -18930,33 +21738,69 @@
return !operator==( rhs );
}
- StructureType sType;
- struct BaseOutStructure* pNext = nullptr;
+ private:
+ using layout::BaseOutStructure::sType;
};
static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BaseOutStructure>::value, "struct wrapper is not a standard layout!" );
- struct BindAccelerationStructureMemoryInfoNV
+ namespace layout
{
- BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV(),
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0,
- uint32_t deviceIndexCount_ = 0,
- const uint32_t* pDeviceIndices_ = nullptr )
- : accelerationStructure( accelerationStructure_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
- , deviceIndexCount( deviceIndexCount_ )
- , pDeviceIndices( pDeviceIndices_ )
+ struct BindAccelerationStructureMemoryInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0,
+ uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr )
+ : accelerationStructure( accelerationStructure_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ , deviceIndexCount( deviceIndexCount_ )
+ , pDeviceIndices( pDeviceIndices_ )
+ {}
+
+ BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
+ }
+
+ BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
+ const void* pNext = nullptr;
+ vk::AccelerationStructureNV accelerationStructure;
+ vk::DeviceMemory memory;
+ vk::DeviceSize memoryOffset;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
+ };
+ static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindAccelerationStructureMemoryInfoNV : public layout::BindAccelerationStructureMemoryInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0,
+ uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr )
+ : layout::BindAccelerationStructureMemoryInfoNV( accelerationStructure_, memory_, memoryOffset_, deviceIndexCount_, pDeviceIndices_ )
{}
BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
- }
+ : layout::BindAccelerationStructureMemoryInfoNV( rhs )
+ {}
BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
+ layout::BindAccelerationStructureMemoryInfoNV::operator=(rhs);
return *this;
}
@@ -18966,19 +21810,19 @@
return *this;
}
- BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ )
+ BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( vk::AccelerationStructureNV accelerationStructure_ )
{
accelerationStructure = accelerationStructure_;
return *this;
}
- BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ )
+ BindAccelerationStructureMemoryInfoNV & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ )
+ BindAccelerationStructureMemoryInfoNV & setMemoryOffset( vk::DeviceSize memoryOffset_ )
{
memoryOffset = memoryOffset_;
return *this;
@@ -19023,34 +21867,56 @@
}
private:
- StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV;
-
- public:
- const void* pNext = nullptr;
- AccelerationStructureNV accelerationStructure;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- uint32_t deviceIndexCount;
- const uint32_t* pDeviceIndices;
+ using layout::BindAccelerationStructureMemoryInfoNV::sType;
};
static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindAccelerationStructureMemoryInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct BindBufferMemoryDeviceGroupInfo
+ namespace layout
{
- BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
- const uint32_t* pDeviceIndices_ = nullptr )
- : deviceIndexCount( deviceIndexCount_ )
- , pDeviceIndices( pDeviceIndices_ )
+ struct BindBufferMemoryDeviceGroupInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr )
+ : deviceIndexCount( deviceIndexCount_ )
+ , pDeviceIndices( pDeviceIndices_ )
+ {}
+
+ BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
+ }
+
+ BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
+ const void* pNext = nullptr;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
+ };
+ static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindBufferMemoryDeviceGroupInfo : public layout::BindBufferMemoryDeviceGroupInfo
+ {
+ VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr )
+ : layout::BindBufferMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_ )
{}
BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
- }
+ : layout::BindBufferMemoryDeviceGroupInfo( rhs )
+ {}
BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
+ layout::BindBufferMemoryDeviceGroupInfo::operator=(rhs);
return *this;
}
@@ -19096,33 +21962,60 @@
}
private:
- StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t deviceIndexCount;
- const uint32_t* pDeviceIndices;
+ using layout::BindBufferMemoryDeviceGroupInfo::sType;
};
static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindBufferMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" );
- struct BindBufferMemoryInfo
+ namespace layout
{
- BindBufferMemoryInfo( Buffer buffer_ = Buffer(),
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0 )
- : buffer( buffer_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
+ struct BindBufferMemoryInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0 )
+ : buffer( buffer_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ {}
+
+ BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindBufferMemoryInfo*>(this) = rhs;
+ }
+
+ BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindBufferMemoryInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindBufferMemoryInfo;
+ const void* pNext = nullptr;
+ vk::Buffer buffer;
+ vk::DeviceMemory memory;
+ vk::DeviceSize memoryOffset;
+ };
+ static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindBufferMemoryInfo : public layout::BindBufferMemoryInfo
+ {
+ VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0 )
+ : layout::BindBufferMemoryInfo( buffer_, memory_, memoryOffset_ )
{}
BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
- }
+ : layout::BindBufferMemoryInfo( rhs )
+ {}
BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
+ layout::BindBufferMemoryInfo::operator=(rhs);
return *this;
}
@@ -19132,19 +22025,19 @@
return *this;
}
- BindBufferMemoryInfo & setBuffer( Buffer buffer_ )
+ BindBufferMemoryInfo & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- BindBufferMemoryInfo & setMemory( DeviceMemory memory_ )
+ BindBufferMemoryInfo & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- BindBufferMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ )
+ BindBufferMemoryInfo & setMemoryOffset( vk::DeviceSize memoryOffset_ )
{
memoryOffset = memoryOffset_;
return *this;
@@ -19175,32 +22068,27 @@
}
private:
- StructureType sType = StructureType::eBindBufferMemoryInfo;
-
- public:
- const void* pNext = nullptr;
- Buffer buffer;
- DeviceMemory memory;
- DeviceSize memoryOffset;
+ using layout::BindBufferMemoryInfo::sType;
};
static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindBufferMemoryInfo>::value, "struct wrapper is not a standard layout!" );
struct Offset2D
{
- Offset2D( int32_t x_ = 0,
- int32_t y_ = 0 )
+ VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = 0,
+ int32_t y_ = 0 )
: x( x_ )
, y( y_ )
{}
Offset2D( VkOffset2D const & rhs )
{
- memcpy( this, &rhs, sizeof( Offset2D ) );
+ *reinterpret_cast<VkOffset2D*>(this) = rhs;
}
Offset2D& operator=( VkOffset2D const & rhs )
{
- memcpy( this, &rhs, sizeof( Offset2D ) );
+ *reinterpret_cast<VkOffset2D*>(this) = rhs;
return *this;
}
@@ -19237,37 +22125,39 @@
return !operator==( rhs );
}
+ public:
int32_t x;
int32_t y;
};
static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Offset2D>::value, "struct wrapper is not a standard layout!" );
struct Rect2D
{
- Rect2D( Offset2D offset_ = Offset2D(),
- Extent2D extent_ = Extent2D() )
+ VULKAN_HPP_CONSTEXPR Rect2D( vk::Offset2D offset_ = vk::Offset2D(),
+ vk::Extent2D extent_ = vk::Extent2D() )
: offset( offset_ )
, extent( extent_ )
{}
Rect2D( VkRect2D const & rhs )
{
- memcpy( this, &rhs, sizeof( Rect2D ) );
+ *reinterpret_cast<VkRect2D*>(this) = rhs;
}
Rect2D& operator=( VkRect2D const & rhs )
{
- memcpy( this, &rhs, sizeof( Rect2D ) );
+ *reinterpret_cast<VkRect2D*>(this) = rhs;
return *this;
}
- Rect2D & setOffset( Offset2D offset_ )
+ Rect2D & setOffset( vk::Offset2D offset_ )
{
offset = offset_;
return *this;
}
- Rect2D & setExtent( Extent2D extent_ )
+ Rect2D & setExtent( vk::Extent2D extent_ )
{
extent = extent_;
return *this;
@@ -19294,31 +22184,66 @@
return !operator==( rhs );
}
- Offset2D offset;
- Extent2D extent;
+ public:
+ vk::Offset2D offset;
+ vk::Extent2D extent;
};
static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Rect2D>::value, "struct wrapper is not a standard layout!" );
- struct BindImageMemoryDeviceGroupInfo
+ namespace layout
{
- BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
- const uint32_t* pDeviceIndices_ = nullptr,
- uint32_t splitInstanceBindRegionCount_ = 0,
- const Rect2D* pSplitInstanceBindRegions_ = nullptr )
- : deviceIndexCount( deviceIndexCount_ )
- , pDeviceIndices( pDeviceIndices_ )
- , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
- , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
+ struct BindImageMemoryDeviceGroupInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr,
+ uint32_t splitInstanceBindRegionCount_ = 0,
+ const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr )
+ : deviceIndexCount( deviceIndexCount_ )
+ , pDeviceIndices( pDeviceIndices_ )
+ , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
+ , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
+ {}
+
+ BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
+ }
+
+ BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
+ const void* pNext = nullptr;
+ uint32_t deviceIndexCount;
+ const uint32_t* pDeviceIndices;
+ uint32_t splitInstanceBindRegionCount;
+ const vk::Rect2D* pSplitInstanceBindRegions;
+ };
+ static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindImageMemoryDeviceGroupInfo : public layout::BindImageMemoryDeviceGroupInfo
+ {
+ VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0,
+ const uint32_t* pDeviceIndices_ = nullptr,
+ uint32_t splitInstanceBindRegionCount_ = 0,
+ const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr )
+ : layout::BindImageMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_, splitInstanceBindRegionCount_, pSplitInstanceBindRegions_ )
{}
BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
- }
+ : layout::BindImageMemoryDeviceGroupInfo( rhs )
+ {}
BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
+ layout::BindImageMemoryDeviceGroupInfo::operator=(rhs);
return *this;
}
@@ -19346,7 +22271,7 @@
return *this;
}
- BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const Rect2D* pSplitInstanceBindRegions_ )
+ BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const vk::Rect2D* pSplitInstanceBindRegions_ )
{
pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
return *this;
@@ -19378,35 +22303,60 @@
}
private:
- StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t deviceIndexCount;
- const uint32_t* pDeviceIndices;
- uint32_t splitInstanceBindRegionCount;
- const Rect2D* pSplitInstanceBindRegions;
+ using layout::BindImageMemoryDeviceGroupInfo::sType;
};
static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindImageMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" );
- struct BindImageMemoryInfo
+ namespace layout
{
- BindImageMemoryInfo( Image image_ = Image(),
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0 )
- : image( image_ )
- , memory( memory_ )
- , memoryOffset( memoryOffset_ )
+ struct BindImageMemoryInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0 )
+ : image( image_ )
+ , memory( memory_ )
+ , memoryOffset( memoryOffset_ )
+ {}
+
+ BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindImageMemoryInfo*>(this) = rhs;
+ }
+
+ BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindImageMemoryInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindImageMemoryInfo;
+ const void* pNext = nullptr;
+ vk::Image image;
+ vk::DeviceMemory memory;
+ vk::DeviceSize memoryOffset;
+ };
+ static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindImageMemoryInfo : public layout::BindImageMemoryInfo
+ {
+ VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0 )
+ : layout::BindImageMemoryInfo( image_, memory_, memoryOffset_ )
{}
BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
- }
+ : layout::BindImageMemoryInfo( rhs )
+ {}
BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
+ layout::BindImageMemoryInfo::operator=(rhs);
return *this;
}
@@ -19416,19 +22366,19 @@
return *this;
}
- BindImageMemoryInfo & setImage( Image image_ )
+ BindImageMemoryInfo & setImage( vk::Image image_ )
{
image = image_;
return *this;
}
- BindImageMemoryInfo & setMemory( DeviceMemory memory_ )
+ BindImageMemoryInfo & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- BindImageMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ )
+ BindImageMemoryInfo & setMemoryOffset( vk::DeviceSize memoryOffset_ )
{
memoryOffset = memoryOffset_;
return *this;
@@ -19459,32 +22409,56 @@
}
private:
- StructureType sType = StructureType::eBindImageMemoryInfo;
-
- public:
- const void* pNext = nullptr;
- Image image;
- DeviceMemory memory;
- DeviceSize memoryOffset;
+ using layout::BindImageMemoryInfo::sType;
};
static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindImageMemoryInfo>::value, "struct wrapper is not a standard layout!" );
- struct BindImageMemorySwapchainInfoKHR
+ namespace layout
{
- BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR(),
- uint32_t imageIndex_ = 0 )
- : swapchain( swapchain_ )
- , imageIndex( imageIndex_ )
+ struct BindImageMemorySwapchainInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
+ uint32_t imageIndex_ = 0 )
+ : swapchain( swapchain_ )
+ , imageIndex( imageIndex_ )
+ {}
+
+ BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
+ }
+
+ BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
+ const void* pNext = nullptr;
+ vk::SwapchainKHR swapchain;
+ uint32_t imageIndex;
+ };
+ static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindImageMemorySwapchainInfoKHR : public layout::BindImageMemorySwapchainInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(),
+ uint32_t imageIndex_ = 0 )
+ : layout::BindImageMemorySwapchainInfoKHR( swapchain_, imageIndex_ )
{}
BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
- }
+ : layout::BindImageMemorySwapchainInfoKHR( rhs )
+ {}
BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
+ layout::BindImageMemorySwapchainInfoKHR::operator=(rhs);
return *this;
}
@@ -19494,7 +22468,7 @@
return *this;
}
- BindImageMemorySwapchainInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+ BindImageMemorySwapchainInfoKHR & setSwapchain( vk::SwapchainKHR swapchain_ )
{
swapchain = swapchain_;
return *this;
@@ -19530,29 +22504,52 @@
}
private:
- StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR;
-
- public:
- const void* pNext = nullptr;
- SwapchainKHR swapchain;
- uint32_t imageIndex;
+ using layout::BindImageMemorySwapchainInfoKHR::sType;
};
static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindImageMemorySwapchainInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct BindImagePlaneMemoryInfo
+ namespace layout
{
- BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
- : planeAspect( planeAspect_ )
+ struct BindImagePlaneMemoryInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+ : planeAspect( planeAspect_ )
+ {}
+
+ BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
+ }
+
+ BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
+ const void* pNext = nullptr;
+ vk::ImageAspectFlagBits planeAspect;
+ };
+ static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindImagePlaneMemoryInfo : public layout::BindImagePlaneMemoryInfo
+ {
+ VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+ : layout::BindImagePlaneMemoryInfo( planeAspect_ )
{}
BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
- }
+ : layout::BindImagePlaneMemoryInfo( rhs )
+ {}
BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
+ layout::BindImagePlaneMemoryInfo::operator=(rhs);
return *this;
}
@@ -19562,7 +22559,7 @@
return *this;
}
- BindImagePlaneMemoryInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+ BindImagePlaneMemoryInfo & setPlaneAspect( vk::ImageAspectFlagBits planeAspect_ )
{
planeAspect = planeAspect_;
return *this;
@@ -19591,21 +22588,18 @@
}
private:
- StructureType sType = StructureType::eBindImagePlaneMemoryInfo;
-
- public:
- const void* pNext = nullptr;
- ImageAspectFlagBits planeAspect;
+ using layout::BindImagePlaneMemoryInfo::sType;
};
static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindImagePlaneMemoryInfo>::value, "struct wrapper is not a standard layout!" );
struct SparseMemoryBind
{
- SparseMemoryBind( DeviceSize resourceOffset_ = 0,
- DeviceSize size_ = 0,
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0,
- SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+ VULKAN_HPP_CONSTEXPR SparseMemoryBind( vk::DeviceSize resourceOffset_ = 0,
+ vk::DeviceSize size_ = 0,
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0,
+ vk::SparseMemoryBindFlags flags_ = vk::SparseMemoryBindFlags() )
: resourceOffset( resourceOffset_ )
, size( size_ )
, memory( memory_ )
@@ -19615,40 +22609,40 @@
SparseMemoryBind( VkSparseMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+ *reinterpret_cast<VkSparseMemoryBind*>(this) = rhs;
}
SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
+ *reinterpret_cast<VkSparseMemoryBind*>(this) = rhs;
return *this;
}
- SparseMemoryBind & setResourceOffset( DeviceSize resourceOffset_ )
+ SparseMemoryBind & setResourceOffset( vk::DeviceSize resourceOffset_ )
{
resourceOffset = resourceOffset_;
return *this;
}
- SparseMemoryBind & setSize( DeviceSize size_ )
+ SparseMemoryBind & setSize( vk::DeviceSize size_ )
{
size = size_;
return *this;
}
- SparseMemoryBind & setMemory( DeviceMemory memory_ )
+ SparseMemoryBind & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- SparseMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ )
+ SparseMemoryBind & setMemoryOffset( vk::DeviceSize memoryOffset_ )
{
memoryOffset = memoryOffset_;
return *this;
}
- SparseMemoryBind & setFlags( SparseMemoryBindFlags flags_ )
+ SparseMemoryBind & setFlags( vk::SparseMemoryBindFlags flags_ )
{
flags = flags_;
return *this;
@@ -19678,19 +22672,21 @@
return !operator==( rhs );
}
- DeviceSize resourceOffset;
- DeviceSize size;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- SparseMemoryBindFlags flags;
+ public:
+ vk::DeviceSize resourceOffset;
+ vk::DeviceSize size;
+ vk::DeviceMemory memory;
+ vk::DeviceSize memoryOffset;
+ vk::SparseMemoryBindFlags flags;
};
static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseMemoryBind>::value, "struct wrapper is not a standard layout!" );
struct SparseBufferMemoryBindInfo
{
- SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(),
- uint32_t bindCount_ = 0,
- const SparseMemoryBind* pBinds_ = nullptr )
+ VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( vk::Buffer buffer_ = vk::Buffer(),
+ uint32_t bindCount_ = 0,
+ const vk::SparseMemoryBind* pBinds_ = nullptr )
: buffer( buffer_ )
, bindCount( bindCount_ )
, pBinds( pBinds_ )
@@ -19698,16 +22694,16 @@
SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+ *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this) = rhs;
}
SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
+ *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this) = rhs;
return *this;
}
- SparseBufferMemoryBindInfo & setBuffer( Buffer buffer_ )
+ SparseBufferMemoryBindInfo & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
@@ -19719,7 +22715,7 @@
return *this;
}
- SparseBufferMemoryBindInfo & setPBinds( const SparseMemoryBind* pBinds_ )
+ SparseBufferMemoryBindInfo & setPBinds( const vk::SparseMemoryBind* pBinds_ )
{
pBinds = pBinds_;
return *this;
@@ -19747,17 +22743,19 @@
return !operator==( rhs );
}
- Buffer buffer;
+ public:
+ vk::Buffer buffer;
uint32_t bindCount;
- const SparseMemoryBind* pBinds;
+ const vk::SparseMemoryBind* pBinds;
};
static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseBufferMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
struct SparseImageOpaqueMemoryBindInfo
{
- SparseImageOpaqueMemoryBindInfo( Image image_ = Image(),
- uint32_t bindCount_ = 0,
- const SparseMemoryBind* pBinds_ = nullptr )
+ VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( vk::Image image_ = vk::Image(),
+ uint32_t bindCount_ = 0,
+ const vk::SparseMemoryBind* pBinds_ = nullptr )
: image( image_ )
, bindCount( bindCount_ )
, pBinds( pBinds_ )
@@ -19765,16 +22763,16 @@
SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+ *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this) = rhs;
}
SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
+ *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this) = rhs;
return *this;
}
- SparseImageOpaqueMemoryBindInfo & setImage( Image image_ )
+ SparseImageOpaqueMemoryBindInfo & setImage( vk::Image image_ )
{
image = image_;
return *this;
@@ -19786,7 +22784,7 @@
return *this;
}
- SparseImageOpaqueMemoryBindInfo & setPBinds( const SparseMemoryBind* pBinds_ )
+ SparseImageOpaqueMemoryBindInfo & setPBinds( const vk::SparseMemoryBind* pBinds_ )
{
pBinds = pBinds_;
return *this;
@@ -19814,17 +22812,19 @@
return !operator==( rhs );
}
- Image image;
+ public:
+ vk::Image image;
uint32_t bindCount;
- const SparseMemoryBind* pBinds;
+ const vk::SparseMemoryBind* pBinds;
};
static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageOpaqueMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
struct ImageSubresource
{
- ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t mipLevel_ = 0,
- uint32_t arrayLayer_ = 0 )
+ VULKAN_HPP_CONSTEXPR ImageSubresource( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
+ uint32_t mipLevel_ = 0,
+ uint32_t arrayLayer_ = 0 )
: aspectMask( aspectMask_ )
, mipLevel( mipLevel_ )
, arrayLayer( arrayLayer_ )
@@ -19832,16 +22832,16 @@
ImageSubresource( VkImageSubresource const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresource ) );
+ *reinterpret_cast<VkImageSubresource*>(this) = rhs;
}
ImageSubresource& operator=( VkImageSubresource const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresource ) );
+ *reinterpret_cast<VkImageSubresource*>(this) = rhs;
return *this;
}
- ImageSubresource & setAspectMask( ImageAspectFlags aspectMask_ )
+ ImageSubresource & setAspectMask( vk::ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
return *this;
@@ -19881,17 +22881,19 @@
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
+ public:
+ vk::ImageAspectFlags aspectMask;
uint32_t mipLevel;
uint32_t arrayLayer;
};
static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageSubresource>::value, "struct wrapper is not a standard layout!" );
struct Offset3D
{
- Offset3D( int32_t x_ = 0,
- int32_t y_ = 0,
- int32_t z_ = 0 )
+ VULKAN_HPP_CONSTEXPR Offset3D( int32_t x_ = 0,
+ int32_t y_ = 0,
+ int32_t z_ = 0 )
: x( x_ )
, y( y_ )
, z( z_ )
@@ -19906,12 +22908,12 @@
Offset3D( VkOffset3D const & rhs )
{
- memcpy( this, &rhs, sizeof( Offset3D ) );
+ *reinterpret_cast<VkOffset3D*>(this) = rhs;
}
Offset3D& operator=( VkOffset3D const & rhs )
{
- memcpy( this, &rhs, sizeof( Offset3D ) );
+ *reinterpret_cast<VkOffset3D*>(this) = rhs;
return *this;
}
@@ -19955,17 +22957,19 @@
return !operator==( rhs );
}
+ public:
int32_t x;
int32_t y;
int32_t z;
};
static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Offset3D>::value, "struct wrapper is not a standard layout!" );
struct Extent3D
{
- Extent3D( uint32_t width_ = 0,
- uint32_t height_ = 0,
- uint32_t depth_ = 0 )
+ VULKAN_HPP_CONSTEXPR Extent3D( uint32_t width_ = 0,
+ uint32_t height_ = 0,
+ uint32_t depth_ = 0 )
: width( width_ )
, height( height_ )
, depth( depth_ )
@@ -19980,12 +22984,12 @@
Extent3D( VkExtent3D const & rhs )
{
- memcpy( this, &rhs, sizeof( Extent3D ) );
+ *reinterpret_cast<VkExtent3D*>(this) = rhs;
}
Extent3D& operator=( VkExtent3D const & rhs )
{
- memcpy( this, &rhs, sizeof( Extent3D ) );
+ *reinterpret_cast<VkExtent3D*>(this) = rhs;
return *this;
}
@@ -20029,20 +23033,22 @@
return !operator==( rhs );
}
+ public:
uint32_t width;
uint32_t height;
uint32_t depth;
};
static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Extent3D>::value, "struct wrapper is not a standard layout!" );
struct SparseImageMemoryBind
{
- SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(),
- Offset3D offset_ = Offset3D(),
- Extent3D extent_ = Extent3D(),
- DeviceMemory memory_ = DeviceMemory(),
- DeviceSize memoryOffset_ = 0,
- SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
+ VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( vk::ImageSubresource subresource_ = vk::ImageSubresource(),
+ vk::Offset3D offset_ = vk::Offset3D(),
+ vk::Extent3D extent_ = vk::Extent3D(),
+ vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize memoryOffset_ = 0,
+ vk::SparseMemoryBindFlags flags_ = vk::SparseMemoryBindFlags() )
: subresource( subresource_ )
, offset( offset_ )
, extent( extent_ )
@@ -20053,46 +23059,46 @@
SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+ *reinterpret_cast<VkSparseImageMemoryBind*>(this) = rhs;
}
SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
+ *reinterpret_cast<VkSparseImageMemoryBind*>(this) = rhs;
return *this;
}
- SparseImageMemoryBind & setSubresource( ImageSubresource subresource_ )
+ SparseImageMemoryBind & setSubresource( vk::ImageSubresource subresource_ )
{
subresource = subresource_;
return *this;
}
- SparseImageMemoryBind & setOffset( Offset3D offset_ )
+ SparseImageMemoryBind & setOffset( vk::Offset3D offset_ )
{
offset = offset_;
return *this;
}
- SparseImageMemoryBind & setExtent( Extent3D extent_ )
+ SparseImageMemoryBind & setExtent( vk::Extent3D extent_ )
{
extent = extent_;
return *this;
}
- SparseImageMemoryBind & setMemory( DeviceMemory memory_ )
+ SparseImageMemoryBind & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- SparseImageMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ )
+ SparseImageMemoryBind & setMemoryOffset( vk::DeviceSize memoryOffset_ )
{
memoryOffset = memoryOffset_;
return *this;
}
- SparseImageMemoryBind & setFlags( SparseMemoryBindFlags flags_ )
+ SparseImageMemoryBind & setFlags( vk::SparseMemoryBindFlags flags_ )
{
flags = flags_;
return *this;
@@ -20123,20 +23129,22 @@
return !operator==( rhs );
}
- ImageSubresource subresource;
- Offset3D offset;
- Extent3D extent;
- DeviceMemory memory;
- DeviceSize memoryOffset;
- SparseMemoryBindFlags flags;
+ public:
+ vk::ImageSubresource subresource;
+ vk::Offset3D offset;
+ vk::Extent3D extent;
+ vk::DeviceMemory memory;
+ vk::DeviceSize memoryOffset;
+ vk::SparseMemoryBindFlags flags;
};
static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageMemoryBind>::value, "struct wrapper is not a standard layout!" );
struct SparseImageMemoryBindInfo
{
- SparseImageMemoryBindInfo( Image image_ = Image(),
- uint32_t bindCount_ = 0,
- const SparseImageMemoryBind* pBinds_ = nullptr )
+ VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( vk::Image image_ = vk::Image(),
+ uint32_t bindCount_ = 0,
+ const vk::SparseImageMemoryBind* pBinds_ = nullptr )
: image( image_ )
, bindCount( bindCount_ )
, pBinds( pBinds_ )
@@ -20144,16 +23152,16 @@
SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+ *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this) = rhs;
}
SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
+ *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this) = rhs;
return *this;
}
- SparseImageMemoryBindInfo & setImage( Image image_ )
+ SparseImageMemoryBindInfo & setImage( vk::Image image_ )
{
image = image_;
return *this;
@@ -20165,7 +23173,7 @@
return *this;
}
- SparseImageMemoryBindInfo & setPBinds( const SparseImageMemoryBind* pBinds_ )
+ SparseImageMemoryBindInfo & setPBinds( const vk::SparseImageMemoryBind* pBinds_ )
{
pBinds = pBinds_;
return *this;
@@ -20193,44 +23201,91 @@
return !operator==( rhs );
}
- Image image;
+ public:
+ vk::Image image;
uint32_t bindCount;
- const SparseImageMemoryBind* pBinds;
+ const vk::SparseImageMemoryBind* pBinds;
};
static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
- struct BindSparseInfo
+ namespace layout
{
- 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 )
- : waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , bufferBindCount( bufferBindCount_ )
- , pBufferBinds( pBufferBinds_ )
- , imageOpaqueBindCount( imageOpaqueBindCount_ )
- , pImageOpaqueBinds( pImageOpaqueBinds_ )
- , imageBindCount( imageBindCount_ )
- , pImageBinds( pImageBinds_ )
- , signalSemaphoreCount( signalSemaphoreCount_ )
- , pSignalSemaphores( pSignalSemaphores_ )
+ struct BindSparseInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
+ const vk::Semaphore* pWaitSemaphores_ = nullptr,
+ uint32_t bufferBindCount_ = 0,
+ const vk::SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
+ uint32_t imageOpaqueBindCount_ = 0,
+ const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
+ uint32_t imageBindCount_ = 0,
+ const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const vk::Semaphore* pSignalSemaphores_ = nullptr )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , bufferBindCount( bufferBindCount_ )
+ , pBufferBinds( pBufferBinds_ )
+ , imageOpaqueBindCount( imageOpaqueBindCount_ )
+ , pImageOpaqueBinds( pImageOpaqueBinds_ )
+ , imageBindCount( imageBindCount_ )
+ , pImageBinds( pImageBinds_ )
+ , signalSemaphoreCount( signalSemaphoreCount_ )
+ , pSignalSemaphores( pSignalSemaphores_ )
+ {}
+
+ BindSparseInfo( VkBindSparseInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindSparseInfo*>(this) = rhs;
+ }
+
+ BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
+ {
+ *reinterpret_cast<VkBindSparseInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBindSparseInfo;
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreCount;
+ const vk::Semaphore* pWaitSemaphores;
+ uint32_t bufferBindCount;
+ const vk::SparseBufferMemoryBindInfo* pBufferBinds;
+ uint32_t imageOpaqueBindCount;
+ const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+ uint32_t imageBindCount;
+ const vk::SparseImageMemoryBindInfo* pImageBinds;
+ uint32_t signalSemaphoreCount;
+ const vk::Semaphore* pSignalSemaphores;
+ };
+ static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BindSparseInfo : public layout::BindSparseInfo
+ {
+ VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
+ const vk::Semaphore* pWaitSemaphores_ = nullptr,
+ uint32_t bufferBindCount_ = 0,
+ const vk::SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
+ uint32_t imageOpaqueBindCount_ = 0,
+ const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
+ uint32_t imageBindCount_ = 0,
+ const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const vk::Semaphore* pSignalSemaphores_ = nullptr )
+ : layout::BindSparseInfo( waitSemaphoreCount_, pWaitSemaphores_, bufferBindCount_, pBufferBinds_, imageOpaqueBindCount_, pImageOpaqueBinds_, imageBindCount_, pImageBinds_, signalSemaphoreCount_, pSignalSemaphores_ )
{}
BindSparseInfo( VkBindSparseInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BindSparseInfo ) );
- }
+ : layout::BindSparseInfo( rhs )
+ {}
BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BindSparseInfo ) );
+ layout::BindSparseInfo::operator=(rhs);
return *this;
}
@@ -20246,7 +23301,7 @@
return *this;
}
- BindSparseInfo & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ BindSparseInfo & setPWaitSemaphores( const vk::Semaphore* pWaitSemaphores_ )
{
pWaitSemaphores = pWaitSemaphores_;
return *this;
@@ -20258,7 +23313,7 @@
return *this;
}
- BindSparseInfo & setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
+ BindSparseInfo & setPBufferBinds( const vk::SparseBufferMemoryBindInfo* pBufferBinds_ )
{
pBufferBinds = pBufferBinds_;
return *this;
@@ -20270,7 +23325,7 @@
return *this;
}
- BindSparseInfo & setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
+ BindSparseInfo & setPImageOpaqueBinds( const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
{
pImageOpaqueBinds = pImageOpaqueBinds_;
return *this;
@@ -20282,7 +23337,7 @@
return *this;
}
- BindSparseInfo & setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
+ BindSparseInfo & setPImageBinds( const vk::SparseImageMemoryBindInfo* pImageBinds_ )
{
pImageBinds = pImageBinds_;
return *this;
@@ -20294,7 +23349,7 @@
return *this;
}
- BindSparseInfo & setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+ BindSparseInfo & setPSignalSemaphores( const vk::Semaphore* pSignalSemaphores_ )
{
pSignalSemaphores = pSignalSemaphores_;
return *this;
@@ -20332,28 +23387,16 @@
}
private:
- StructureType sType = StructureType::eBindSparseInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- uint32_t bufferBindCount;
- const SparseBufferMemoryBindInfo* pBufferBinds;
- uint32_t imageOpaqueBindCount;
- const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
- uint32_t imageBindCount;
- const SparseImageMemoryBindInfo* pImageBinds;
- uint32_t signalSemaphoreCount;
- const Semaphore* pSignalSemaphores;
+ using layout::BindSparseInfo::sType;
};
static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BindSparseInfo>::value, "struct wrapper is not a standard layout!" );
struct BufferCopy
{
- BufferCopy( DeviceSize srcOffset_ = 0,
- DeviceSize dstOffset_ = 0,
- DeviceSize size_ = 0 )
+ VULKAN_HPP_CONSTEXPR BufferCopy( vk::DeviceSize srcOffset_ = 0,
+ vk::DeviceSize dstOffset_ = 0,
+ vk::DeviceSize size_ = 0 )
: srcOffset( srcOffset_ )
, dstOffset( dstOffset_ )
, size( size_ )
@@ -20361,28 +23404,28 @@
BufferCopy( VkBufferCopy const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferCopy ) );
+ *reinterpret_cast<VkBufferCopy*>(this) = rhs;
}
BufferCopy& operator=( VkBufferCopy const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferCopy ) );
+ *reinterpret_cast<VkBufferCopy*>(this) = rhs;
return *this;
}
- BufferCopy & setSrcOffset( DeviceSize srcOffset_ )
+ BufferCopy & setSrcOffset( vk::DeviceSize srcOffset_ )
{
srcOffset = srcOffset_;
return *this;
}
- BufferCopy & setDstOffset( DeviceSize dstOffset_ )
+ BufferCopy & setDstOffset( vk::DeviceSize dstOffset_ )
{
dstOffset = dstOffset_;
return *this;
}
- BufferCopy & setSize( DeviceSize size_ )
+ BufferCopy & setSize( vk::DeviceSize size_ )
{
size = size_;
return *this;
@@ -20410,36 +23453,75 @@
return !operator==( rhs );
}
- DeviceSize srcOffset;
- DeviceSize dstOffset;
- DeviceSize size;
+ public:
+ vk::DeviceSize srcOffset;
+ vk::DeviceSize dstOffset;
+ vk::DeviceSize size;
};
static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferCopy>::value, "struct wrapper is not a standard layout!" );
- struct BufferCreateInfo
+ namespace layout
{
- BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
- DeviceSize size_ = 0,
- BufferUsageFlags usage_ = BufferUsageFlags(),
- SharingMode sharingMode_ = SharingMode::eExclusive,
- uint32_t queueFamilyIndexCount_ = 0,
- const uint32_t* pQueueFamilyIndices_ = nullptr )
- : flags( flags_ )
- , size( size_ )
- , usage( usage_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ struct BufferCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+ vk::DeviceSize size_ = 0,
+ vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+ vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr )
+ : flags( flags_ )
+ , size( size_ )
+ , usage( usage_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ {}
+
+ BufferCreateInfo( VkBufferCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkBufferCreateInfo*>(this) = rhs;
+ }
+
+ BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkBufferCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBufferCreateInfo;
+ const void* pNext = nullptr;
+ vk::BufferCreateFlags flags;
+ vk::DeviceSize size;
+ vk::BufferUsageFlags usage;
+ vk::SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ };
+ static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BufferCreateInfo : public layout::BufferCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+ vk::DeviceSize size_ = 0,
+ vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+ vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr )
+ : layout::BufferCreateInfo( flags_, size_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ )
{}
BufferCreateInfo( VkBufferCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
- }
+ : layout::BufferCreateInfo( rhs )
+ {}
BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
+ layout::BufferCreateInfo::operator=(rhs);
return *this;
}
@@ -20449,25 +23531,25 @@
return *this;
}
- BufferCreateInfo & setFlags( BufferCreateFlags flags_ )
+ BufferCreateInfo & setFlags( vk::BufferCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- BufferCreateInfo & setSize( DeviceSize size_ )
+ BufferCreateInfo & setSize( vk::DeviceSize size_ )
{
size = size_;
return *this;
}
- BufferCreateInfo & setUsage( BufferUsageFlags usage_ )
+ BufferCreateInfo & setUsage( vk::BufferUsageFlags usage_ )
{
usage = usage_;
return *this;
}
- BufferCreateInfo & setSharingMode( SharingMode sharingMode_ )
+ BufferCreateInfo & setSharingMode( vk::SharingMode sharingMode_ )
{
sharingMode = sharingMode_;
return *this;
@@ -20513,33 +23595,52 @@
}
private:
- StructureType sType = StructureType::eBufferCreateInfo;
-
- public:
- const void* pNext = nullptr;
- BufferCreateFlags flags;
- DeviceSize size;
- BufferUsageFlags usage;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
+ using layout::BufferCreateInfo::sType;
};
static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct BufferDeviceAddressCreateInfoEXT
+ namespace layout
{
- BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = 0 )
- : deviceAddress( deviceAddress_ )
+ struct BufferDeviceAddressCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 )
+ : deviceAddress( deviceAddress_ )
+ {}
+
+ BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
+ }
+
+ BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::DeviceAddress deviceAddress;
+ };
+ static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BufferDeviceAddressCreateInfoEXT : public layout::BufferDeviceAddressCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 )
+ : layout::BufferDeviceAddressCreateInfoEXT( deviceAddress_ )
{}
BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) );
- }
+ : layout::BufferDeviceAddressCreateInfoEXT( rhs )
+ {}
BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferDeviceAddressCreateInfoEXT ) );
+ layout::BufferDeviceAddressCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -20549,7 +23650,7 @@
return *this;
}
- BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ )
+ BufferDeviceAddressCreateInfoEXT & setDeviceAddress( vk::DeviceAddress deviceAddress_ )
{
deviceAddress = deviceAddress_;
return *this;
@@ -20578,28 +23679,52 @@
}
private:
- StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DeviceAddress deviceAddress;
+ using layout::BufferDeviceAddressCreateInfoEXT::sType;
};
static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferDeviceAddressCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct BufferDeviceAddressInfoEXT
+ namespace layout
{
- BufferDeviceAddressInfoEXT( Buffer buffer_ = Buffer() )
- : buffer( buffer_ )
+ struct BufferDeviceAddressInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() )
+ : buffer( buffer_ )
+ {}
+
+ BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
+ }
+
+ BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT;
+ const void* pNext = nullptr;
+ vk::Buffer buffer;
+ };
+ static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BufferDeviceAddressInfoEXT : public layout::BufferDeviceAddressInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() )
+ : layout::BufferDeviceAddressInfoEXT( buffer_ )
{}
BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( BufferDeviceAddressInfoEXT ) );
- }
+ : layout::BufferDeviceAddressInfoEXT( rhs )
+ {}
BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferDeviceAddressInfoEXT ) );
+ layout::BufferDeviceAddressInfoEXT::operator=(rhs);
return *this;
}
@@ -20609,7 +23734,7 @@
return *this;
}
- BufferDeviceAddressInfoEXT & setBuffer( Buffer buffer_ )
+ BufferDeviceAddressInfoEXT & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
@@ -20638,20 +23763,17 @@
}
private:
- StructureType sType = StructureType::eBufferDeviceAddressInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Buffer buffer;
+ using layout::BufferDeviceAddressInfoEXT::sType;
};
static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferDeviceAddressInfoEXT>::value, "struct wrapper is not a standard layout!" );
struct ImageSubresourceLayers
{
- ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t mipLevel_ = 0,
- uint32_t baseArrayLayer_ = 0,
- uint32_t layerCount_ = 0 )
+ VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
+ uint32_t mipLevel_ = 0,
+ uint32_t baseArrayLayer_ = 0,
+ uint32_t layerCount_ = 0 )
: aspectMask( aspectMask_ )
, mipLevel( mipLevel_ )
, baseArrayLayer( baseArrayLayer_ )
@@ -20660,16 +23782,16 @@
ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
+ *reinterpret_cast<VkImageSubresourceLayers*>(this) = rhs;
}
ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
+ *reinterpret_cast<VkImageSubresourceLayers*>(this) = rhs;
return *this;
}
- ImageSubresourceLayers & setAspectMask( ImageAspectFlags aspectMask_ )
+ ImageSubresourceLayers & setAspectMask( vk::ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
return *this;
@@ -20716,21 +23838,23 @@
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
+ public:
+ vk::ImageAspectFlags aspectMask;
uint32_t mipLevel;
uint32_t baseArrayLayer;
uint32_t layerCount;
};
static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageSubresourceLayers>::value, "struct wrapper is not a standard layout!" );
struct BufferImageCopy
{
- BufferImageCopy( DeviceSize bufferOffset_ = 0,
- uint32_t bufferRowLength_ = 0,
- uint32_t bufferImageHeight_ = 0,
- ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
- Offset3D imageOffset_ = Offset3D(),
- Extent3D imageExtent_ = Extent3D() )
+ VULKAN_HPP_CONSTEXPR BufferImageCopy( vk::DeviceSize bufferOffset_ = 0,
+ uint32_t bufferRowLength_ = 0,
+ uint32_t bufferImageHeight_ = 0,
+ vk::ImageSubresourceLayers imageSubresource_ = vk::ImageSubresourceLayers(),
+ vk::Offset3D imageOffset_ = vk::Offset3D(),
+ vk::Extent3D imageExtent_ = vk::Extent3D() )
: bufferOffset( bufferOffset_ )
, bufferRowLength( bufferRowLength_ )
, bufferImageHeight( bufferImageHeight_ )
@@ -20741,16 +23865,16 @@
BufferImageCopy( VkBufferImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferImageCopy ) );
+ *reinterpret_cast<VkBufferImageCopy*>(this) = rhs;
}
BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferImageCopy ) );
+ *reinterpret_cast<VkBufferImageCopy*>(this) = rhs;
return *this;
}
- BufferImageCopy & setBufferOffset( DeviceSize bufferOffset_ )
+ BufferImageCopy & setBufferOffset( vk::DeviceSize bufferOffset_ )
{
bufferOffset = bufferOffset_;
return *this;
@@ -20768,19 +23892,19 @@
return *this;
}
- BufferImageCopy & setImageSubresource( ImageSubresourceLayers imageSubresource_ )
+ BufferImageCopy & setImageSubresource( vk::ImageSubresourceLayers imageSubresource_ )
{
imageSubresource = imageSubresource_;
return *this;
}
- BufferImageCopy & setImageOffset( Offset3D imageOffset_ )
+ BufferImageCopy & setImageOffset( vk::Offset3D imageOffset_ )
{
imageOffset = imageOffset_;
return *this;
}
- BufferImageCopy & setImageExtent( Extent3D imageExtent_ )
+ BufferImageCopy & setImageExtent( vk::Extent3D imageExtent_ )
{
imageExtent = imageExtent_;
return *this;
@@ -20811,41 +23935,82 @@
return !operator==( rhs );
}
- DeviceSize bufferOffset;
+ public:
+ vk::DeviceSize bufferOffset;
uint32_t bufferRowLength;
uint32_t bufferImageHeight;
- ImageSubresourceLayers imageSubresource;
- Offset3D imageOffset;
- Extent3D imageExtent;
+ vk::ImageSubresourceLayers imageSubresource;
+ vk::Offset3D imageOffset;
+ vk::Extent3D imageExtent;
};
static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferImageCopy>::value, "struct wrapper is not a standard layout!" );
- struct BufferMemoryBarrier
+ namespace layout
{
- BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- uint32_t srcQueueFamilyIndex_ = 0,
- uint32_t dstQueueFamilyIndex_ = 0,
- Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0,
- DeviceSize size_ = 0 )
- : srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
- , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
- , buffer( buffer_ )
- , offset( offset_ )
- , size( size_ )
+ struct BufferMemoryBarrier
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ uint32_t srcQueueFamilyIndex_ = 0,
+ uint32_t dstQueueFamilyIndex_ = 0,
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize size_ = 0 )
+ : srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+ , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+ , buffer( buffer_ )
+ , offset( offset_ )
+ , size( size_ )
+ {}
+
+ BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
+ {
+ *reinterpret_cast<VkBufferMemoryBarrier*>(this) = rhs;
+ }
+
+ BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
+ {
+ *reinterpret_cast<VkBufferMemoryBarrier*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBufferMemoryBarrier;
+ const void* pNext = nullptr;
+ vk::AccessFlags srcAccessMask;
+ vk::AccessFlags dstAccessMask;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ vk::Buffer buffer;
+ vk::DeviceSize offset;
+ vk::DeviceSize size;
+ };
+ static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BufferMemoryBarrier : public layout::BufferMemoryBarrier
+ {
+ VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ uint32_t srcQueueFamilyIndex_ = 0,
+ uint32_t dstQueueFamilyIndex_ = 0,
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize size_ = 0 )
+ : layout::BufferMemoryBarrier( srcAccessMask_, dstAccessMask_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, buffer_, offset_, size_ )
{}
BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
- {
- memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
- }
+ : layout::BufferMemoryBarrier( rhs )
+ {}
BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
+ layout::BufferMemoryBarrier::operator=(rhs);
return *this;
}
@@ -20855,13 +24020,13 @@
return *this;
}
- BufferMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+ BufferMemoryBarrier & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
{
srcAccessMask = srcAccessMask_;
return *this;
}
- BufferMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+ BufferMemoryBarrier & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
{
dstAccessMask = dstAccessMask_;
return *this;
@@ -20879,19 +24044,19 @@
return *this;
}
- BufferMemoryBarrier & setBuffer( Buffer buffer_ )
+ BufferMemoryBarrier & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- BufferMemoryBarrier & setOffset( DeviceSize offset_ )
+ BufferMemoryBarrier & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
}
- BufferMemoryBarrier & setSize( DeviceSize size_ )
+ BufferMemoryBarrier & setSize( vk::DeviceSize size_ )
{
size = size_;
return *this;
@@ -20926,34 +24091,52 @@
}
private:
- StructureType sType = StructureType::eBufferMemoryBarrier;
-
- public:
- const void* pNext = nullptr;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- Buffer buffer;
- DeviceSize offset;
- DeviceSize size;
+ using layout::BufferMemoryBarrier::sType;
};
static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferMemoryBarrier>::value, "struct wrapper is not a standard layout!" );
- struct BufferMemoryRequirementsInfo2
+ namespace layout
{
- BufferMemoryRequirementsInfo2( Buffer buffer_ = Buffer() )
- : buffer( buffer_ )
+ struct BufferMemoryRequirementsInfo2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() )
+ : buffer( buffer_ )
+ {}
+
+ BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
+ }
+
+ BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
+ const void* pNext = nullptr;
+ vk::Buffer buffer;
+ };
+ static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BufferMemoryRequirementsInfo2 : public layout::BufferMemoryRequirementsInfo2
+ {
+ VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() )
+ : layout::BufferMemoryRequirementsInfo2( buffer_ )
{}
BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
- }
+ : layout::BufferMemoryRequirementsInfo2( rhs )
+ {}
BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
+ layout::BufferMemoryRequirementsInfo2::operator=(rhs);
return *this;
}
@@ -20963,7 +24146,7 @@
return *this;
}
- BufferMemoryRequirementsInfo2 & setBuffer( Buffer buffer_ )
+ BufferMemoryRequirementsInfo2 & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
@@ -20992,36 +24175,68 @@
}
private:
- StructureType sType = StructureType::eBufferMemoryRequirementsInfo2;
-
- public:
- const void* pNext = nullptr;
- Buffer buffer;
+ using layout::BufferMemoryRequirementsInfo2::sType;
};
static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
- struct BufferViewCreateInfo
+ namespace layout
{
- BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(),
- Buffer buffer_ = Buffer(),
- Format format_ = Format::eUndefined,
- DeviceSize offset_ = 0,
- DeviceSize range_ = 0 )
- : flags( flags_ )
- , buffer( buffer_ )
- , format( format_ )
- , offset( offset_ )
- , range( range_ )
+ struct BufferViewCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(),
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize range_ = 0 )
+ : flags( flags_ )
+ , buffer( buffer_ )
+ , format( format_ )
+ , offset( offset_ )
+ , range( range_ )
+ {}
+
+ BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkBufferViewCreateInfo*>(this) = rhs;
+ }
+
+ BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkBufferViewCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eBufferViewCreateInfo;
+ const void* pNext = nullptr;
+ vk::BufferViewCreateFlags flags;
+ vk::Buffer buffer;
+ vk::Format format;
+ vk::DeviceSize offset;
+ vk::DeviceSize range;
+ };
+ static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct BufferViewCreateInfo : public layout::BufferViewCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(),
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize range_ = 0 )
+ : layout::BufferViewCreateInfo( flags_, buffer_, format_, offset_, range_ )
{}
BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
- }
+ : layout::BufferViewCreateInfo( rhs )
+ {}
BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
+ layout::BufferViewCreateInfo::operator=(rhs);
return *this;
}
@@ -21031,31 +24246,31 @@
return *this;
}
- BufferViewCreateInfo & setFlags( BufferViewCreateFlags flags_ )
+ BufferViewCreateInfo & setFlags( vk::BufferViewCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- BufferViewCreateInfo & setBuffer( Buffer buffer_ )
+ BufferViewCreateInfo & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- BufferViewCreateInfo & setFormat( Format format_ )
+ BufferViewCreateInfo & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- BufferViewCreateInfo & setOffset( DeviceSize offset_ )
+ BufferViewCreateInfo & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
}
- BufferViewCreateInfo & setRange( DeviceSize range_ )
+ BufferViewCreateInfo & setRange( vk::DeviceSize range_ )
{
range = range_;
return *this;
@@ -21088,32 +24303,52 @@
}
private:
- StructureType sType = StructureType::eBufferViewCreateInfo;
-
- public:
- const void* pNext = nullptr;
- BufferViewCreateFlags flags;
- Buffer buffer;
- Format format;
- DeviceSize offset;
- DeviceSize range;
+ using layout::BufferViewCreateInfo::sType;
};
static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<BufferViewCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct CalibratedTimestampInfoEXT
+ namespace layout
{
- CalibratedTimestampInfoEXT( TimeDomainEXT timeDomain_ = TimeDomainEXT::eDevice )
- : timeDomain( timeDomain_ )
+ struct CalibratedTimestampInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice )
+ : timeDomain( timeDomain_ )
+ {}
+
+ CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this) = rhs;
+ }
+
+ CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
+ const void* pNext = nullptr;
+ vk::TimeDomainEXT timeDomain;
+ };
+ static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CalibratedTimestampInfoEXT : public layout::CalibratedTimestampInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice )
+ : layout::CalibratedTimestampInfoEXT( timeDomain_ )
{}
CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
- }
+ : layout::CalibratedTimestampInfoEXT( rhs )
+ {}
CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
+ layout::CalibratedTimestampInfoEXT::operator=(rhs);
return *this;
}
@@ -21123,7 +24358,7 @@
return *this;
}
- CalibratedTimestampInfoEXT & setTimeDomain( TimeDomainEXT timeDomain_ )
+ CalibratedTimestampInfoEXT & setTimeDomain( vk::TimeDomainEXT timeDomain_ )
{
timeDomain = timeDomain_;
return *this;
@@ -21152,16 +24387,55 @@
}
private:
- StructureType sType = StructureType::eCalibratedTimestampInfoEXT;
-
- public:
- const void* pNext = nullptr;
- TimeDomainEXT timeDomain;
+ using layout::CalibratedTimestampInfoEXT::sType;
};
static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CalibratedTimestampInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct CheckpointDataNV
+ namespace layout
{
+ struct CheckpointDataNV
+ {
+ protected:
+ CheckpointDataNV()
+ {}
+
+ CheckpointDataNV( VkCheckpointDataNV const & rhs )
+ {
+ *reinterpret_cast<VkCheckpointDataNV*>(this) = rhs;
+ }
+
+ CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs )
+ {
+ *reinterpret_cast<VkCheckpointDataNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCheckpointDataNV;
+ void* pNext = nullptr;
+ vk::PipelineStageFlagBits stage;
+ void* pCheckpointMarker;
+ };
+ static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CheckpointDataNV : public layout::CheckpointDataNV
+ {
+ CheckpointDataNV()
+ : layout::CheckpointDataNV()
+ {}
+
+ CheckpointDataNV( VkCheckpointDataNV const & rhs )
+ : layout::CheckpointDataNV( rhs )
+ {}
+
+ CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs )
+ {
+ layout::CheckpointDataNV::operator=(rhs);
+ return *this;
+ }
+
operator VkCheckpointDataNV const&() const
{
return *reinterpret_cast<const VkCheckpointDataNV*>( this );
@@ -21186,14 +24460,10 @@
}
private:
- StructureType sType = StructureType::eCheckpointDataNV;
-
- public:
- void* pNext = nullptr;
- PipelineStageFlagBits stage;
- void* pCheckpointMarker;
+ using layout::CheckpointDataNV::sType;
};
static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CheckpointDataNV>::value, "struct wrapper is not a standard layout!" );
union ClearColorValue
{
@@ -21212,7 +24482,6 @@
memcpy( uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
}
-
ClearColorValue & setFloat32( std::array<float,4> float32_ )
{
memcpy( float32, float32_.data(), 4 * sizeof( float ) );
@@ -21247,20 +24516,20 @@
struct ClearDepthStencilValue
{
- ClearDepthStencilValue( float depth_ = 0,
- uint32_t stencil_ = 0 )
+ VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( float depth_ = 0,
+ uint32_t stencil_ = 0 )
: depth( depth_ )
, stencil( stencil_ )
{}
ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
{
- memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
+ *reinterpret_cast<VkClearDepthStencilValue*>(this) = rhs;
}
ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
{
- memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
+ *reinterpret_cast<VkClearDepthStencilValue*>(this) = rhs;
return *this;
}
@@ -21297,31 +24566,32 @@
return !operator==( rhs );
}
+ public:
float depth;
uint32_t stencil;
};
static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ClearDepthStencilValue>::value, "struct wrapper is not a standard layout!" );
union ClearValue
{
- ClearValue( ClearColorValue color_ = ClearColorValue() )
+ ClearValue( vk::ClearColorValue color_ = vk::ClearColorValue() )
{
color = color_;
}
- ClearValue( ClearDepthStencilValue depthStencil_ )
+ ClearValue( vk::ClearDepthStencilValue depthStencil_ )
{
depthStencil = depthStencil_;
}
-
- ClearValue & setColor( ClearColorValue color_ )
+ ClearValue & setColor( vk::ClearColorValue color_ )
{
color = color_;
return *this;
}
- ClearValue & setDepthStencil( ClearDepthStencilValue depthStencil_ )
+ ClearValue & setDepthStencil( vk::ClearDepthStencilValue depthStencil_ )
{
depthStencil = depthStencil_;
return *this;
@@ -21337,8 +24607,8 @@
}
#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
- ClearColorValue color;
- ClearDepthStencilValue depthStencil;
+ vk::ClearColorValue color;
+ vk::ClearDepthStencilValue depthStencil;
#else
VkClearColorValue color;
VkClearDepthStencilValue depthStencil;
@@ -21347,9 +24617,9 @@
struct ClearAttachment
{
- ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
+ ClearAttachment( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
uint32_t colorAttachment_ = 0,
- ClearValue clearValue_ = ClearValue() )
+ vk::ClearValue clearValue_ = vk::ClearValue() )
: aspectMask( aspectMask_ )
, colorAttachment( colorAttachment_ )
, clearValue( clearValue_ )
@@ -21357,16 +24627,16 @@
ClearAttachment( VkClearAttachment const & rhs )
{
- memcpy( this, &rhs, sizeof( ClearAttachment ) );
+ *reinterpret_cast<VkClearAttachment*>(this) = rhs;
}
ClearAttachment& operator=( VkClearAttachment const & rhs )
{
- memcpy( this, &rhs, sizeof( ClearAttachment ) );
+ *reinterpret_cast<VkClearAttachment*>(this) = rhs;
return *this;
}
- ClearAttachment & setAspectMask( ImageAspectFlags aspectMask_ )
+ ClearAttachment & setAspectMask( vk::ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
return *this;
@@ -21378,7 +24648,7 @@
return *this;
}
- ClearAttachment & setClearValue( ClearValue clearValue_ )
+ ClearAttachment & setClearValue( vk::ClearValue clearValue_ )
{
clearValue = clearValue_;
return *this;
@@ -21394,17 +24664,19 @@
return *reinterpret_cast<VkClearAttachment*>( this );
}
- ImageAspectFlags aspectMask;
+ public:
+ vk::ImageAspectFlags aspectMask;
uint32_t colorAttachment;
- ClearValue clearValue;
+ vk::ClearValue clearValue;
};
static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ClearAttachment>::value, "struct wrapper is not a standard layout!" );
struct ClearRect
{
- ClearRect( Rect2D rect_ = Rect2D(),
- uint32_t baseArrayLayer_ = 0,
- uint32_t layerCount_ = 0 )
+ VULKAN_HPP_CONSTEXPR ClearRect( vk::Rect2D rect_ = vk::Rect2D(),
+ uint32_t baseArrayLayer_ = 0,
+ uint32_t layerCount_ = 0 )
: rect( rect_ )
, baseArrayLayer( baseArrayLayer_ )
, layerCount( layerCount_ )
@@ -21412,16 +24684,16 @@
ClearRect( VkClearRect const & rhs )
{
- memcpy( this, &rhs, sizeof( ClearRect ) );
+ *reinterpret_cast<VkClearRect*>(this) = rhs;
}
ClearRect& operator=( VkClearRect const & rhs )
{
- memcpy( this, &rhs, sizeof( ClearRect ) );
+ *reinterpret_cast<VkClearRect*>(this) = rhs;
return *this;
}
- ClearRect & setRect( Rect2D rect_ )
+ ClearRect & setRect( vk::Rect2D rect_ )
{
rect = rect_;
return *this;
@@ -21461,17 +24733,19 @@
return !operator==( rhs );
}
- Rect2D rect;
+ public:
+ vk::Rect2D rect;
uint32_t baseArrayLayer;
uint32_t layerCount;
};
static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ClearRect>::value, "struct wrapper is not a standard layout!" );
struct IndirectCommandsTokenNVX
{
- IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
- Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0 )
+ VULKAN_HPP_CONSTEXPR IndirectCommandsTokenNVX( vk::IndirectCommandsTokenTypeNVX tokenType_ = vk::IndirectCommandsTokenTypeNVX::ePipeline,
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceSize offset_ = 0 )
: tokenType( tokenType_ )
, buffer( buffer_ )
, offset( offset_ )
@@ -21479,28 +24753,28 @@
IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
+ *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this) = rhs;
}
IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
+ *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this) = rhs;
return *this;
}
- IndirectCommandsTokenNVX & setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ IndirectCommandsTokenNVX & setTokenType( vk::IndirectCommandsTokenTypeNVX tokenType_ )
{
tokenType = tokenType_;
return *this;
}
- IndirectCommandsTokenNVX & setBuffer( Buffer buffer_ )
+ IndirectCommandsTokenNVX & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- IndirectCommandsTokenNVX & setOffset( DeviceSize offset_ )
+ IndirectCommandsTokenNVX & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
@@ -21528,44 +24802,91 @@
return !operator==( rhs );
}
- IndirectCommandsTokenTypeNVX tokenType;
- Buffer buffer;
- DeviceSize offset;
+ public:
+ vk::IndirectCommandsTokenTypeNVX tokenType;
+ vk::Buffer buffer;
+ vk::DeviceSize offset;
};
static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<IndirectCommandsTokenNVX>::value, "struct wrapper is not a standard layout!" );
- struct CmdProcessCommandsInfoNVX
+ namespace layout
{
- CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
- IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
- uint32_t indirectCommandsTokenCount_ = 0,
- const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
- uint32_t maxSequencesCount_ = 0,
- CommandBuffer targetCommandBuffer_ = CommandBuffer(),
- Buffer sequencesCountBuffer_ = Buffer(),
- DeviceSize sequencesCountOffset_ = 0,
- Buffer sequencesIndexBuffer_ = Buffer(),
- DeviceSize sequencesIndexOffset_ = 0 )
- : objectTable( objectTable_ )
- , indirectCommandsLayout( indirectCommandsLayout_ )
- , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
- , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
- , maxSequencesCount( maxSequencesCount_ )
- , targetCommandBuffer( targetCommandBuffer_ )
- , sequencesCountBuffer( sequencesCountBuffer_ )
- , sequencesCountOffset( sequencesCountOffset_ )
- , sequencesIndexBuffer( sequencesIndexBuffer_ )
- , sequencesIndexOffset( sequencesIndexOffset_ )
+ struct CmdProcessCommandsInfoNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
+ uint32_t indirectCommandsTokenCount_ = 0,
+ const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
+ uint32_t maxSequencesCount_ = 0,
+ vk::CommandBuffer targetCommandBuffer_ = vk::CommandBuffer(),
+ vk::Buffer sequencesCountBuffer_ = vk::Buffer(),
+ vk::DeviceSize sequencesCountOffset_ = 0,
+ vk::Buffer sequencesIndexBuffer_ = vk::Buffer(),
+ vk::DeviceSize sequencesIndexOffset_ = 0 )
+ : objectTable( objectTable_ )
+ , indirectCommandsLayout( indirectCommandsLayout_ )
+ , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
+ , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
+ , maxSequencesCount( maxSequencesCount_ )
+ , targetCommandBuffer( targetCommandBuffer_ )
+ , sequencesCountBuffer( sequencesCountBuffer_ )
+ , sequencesCountOffset( sequencesCountOffset_ )
+ , sequencesIndexBuffer( sequencesIndexBuffer_ )
+ , sequencesIndexOffset( sequencesIndexOffset_ )
+ {}
+
+ CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
+ }
+
+ CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
+ const void* pNext = nullptr;
+ vk::ObjectTableNVX objectTable;
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
+ uint32_t indirectCommandsTokenCount;
+ const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens;
+ uint32_t maxSequencesCount;
+ vk::CommandBuffer targetCommandBuffer;
+ vk::Buffer sequencesCountBuffer;
+ vk::DeviceSize sequencesCountOffset;
+ vk::Buffer sequencesIndexBuffer;
+ vk::DeviceSize sequencesIndexOffset;
+ };
+ static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CmdProcessCommandsInfoNVX : public layout::CmdProcessCommandsInfoNVX
+ {
+ VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
+ uint32_t indirectCommandsTokenCount_ = 0,
+ const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
+ uint32_t maxSequencesCount_ = 0,
+ vk::CommandBuffer targetCommandBuffer_ = vk::CommandBuffer(),
+ vk::Buffer sequencesCountBuffer_ = vk::Buffer(),
+ vk::DeviceSize sequencesCountOffset_ = 0,
+ vk::Buffer sequencesIndexBuffer_ = vk::Buffer(),
+ vk::DeviceSize sequencesIndexOffset_ = 0 )
+ : layout::CmdProcessCommandsInfoNVX( objectTable_, indirectCommandsLayout_, indirectCommandsTokenCount_, pIndirectCommandsTokens_, maxSequencesCount_, targetCommandBuffer_, sequencesCountBuffer_, sequencesCountOffset_, sequencesIndexBuffer_, sequencesIndexOffset_ )
{}
CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
- }
+ : layout::CmdProcessCommandsInfoNVX( rhs )
+ {}
CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
+ layout::CmdProcessCommandsInfoNVX::operator=(rhs);
return *this;
}
@@ -21575,13 +24896,13 @@
return *this;
}
- CmdProcessCommandsInfoNVX & setObjectTable( ObjectTableNVX objectTable_ )
+ CmdProcessCommandsInfoNVX & setObjectTable( vk::ObjectTableNVX objectTable_ )
{
objectTable = objectTable_;
return *this;
}
- CmdProcessCommandsInfoNVX & setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+ CmdProcessCommandsInfoNVX & setIndirectCommandsLayout( vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ )
{
indirectCommandsLayout = indirectCommandsLayout_;
return *this;
@@ -21593,7 +24914,7 @@
return *this;
}
- CmdProcessCommandsInfoNVX & setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
+ CmdProcessCommandsInfoNVX & setPIndirectCommandsTokens( const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
{
pIndirectCommandsTokens = pIndirectCommandsTokens_;
return *this;
@@ -21605,31 +24926,31 @@
return *this;
}
- CmdProcessCommandsInfoNVX & setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
+ CmdProcessCommandsInfoNVX & setTargetCommandBuffer( vk::CommandBuffer targetCommandBuffer_ )
{
targetCommandBuffer = targetCommandBuffer_;
return *this;
}
- CmdProcessCommandsInfoNVX & setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
+ CmdProcessCommandsInfoNVX & setSequencesCountBuffer( vk::Buffer sequencesCountBuffer_ )
{
sequencesCountBuffer = sequencesCountBuffer_;
return *this;
}
- CmdProcessCommandsInfoNVX & setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
+ CmdProcessCommandsInfoNVX & setSequencesCountOffset( vk::DeviceSize sequencesCountOffset_ )
{
sequencesCountOffset = sequencesCountOffset_;
return *this;
}
- CmdProcessCommandsInfoNVX & setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
+ CmdProcessCommandsInfoNVX & setSequencesIndexBuffer( vk::Buffer sequencesIndexBuffer_ )
{
sequencesIndexBuffer = sequencesIndexBuffer_;
return *this;
}
- CmdProcessCommandsInfoNVX & setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
+ CmdProcessCommandsInfoNVX & setSequencesIndexOffset( vk::DeviceSize sequencesIndexOffset_ )
{
sequencesIndexOffset = sequencesIndexOffset_;
return *this;
@@ -21667,41 +24988,60 @@
}
private:
- StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
-
- public:
- const void* pNext = nullptr;
- ObjectTableNVX objectTable;
- IndirectCommandsLayoutNVX indirectCommandsLayout;
- uint32_t indirectCommandsTokenCount;
- const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
- uint32_t maxSequencesCount;
- CommandBuffer targetCommandBuffer;
- Buffer sequencesCountBuffer;
- DeviceSize sequencesCountOffset;
- Buffer sequencesIndexBuffer;
- DeviceSize sequencesIndexOffset;
+ using layout::CmdProcessCommandsInfoNVX::sType;
};
static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CmdProcessCommandsInfoNVX>::value, "struct wrapper is not a standard layout!" );
- struct CmdReserveSpaceForCommandsInfoNVX
+ namespace layout
{
- CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(),
- IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
- uint32_t maxSequencesCount_ = 0 )
- : objectTable( objectTable_ )
- , indirectCommandsLayout( indirectCommandsLayout_ )
- , maxSequencesCount( maxSequencesCount_ )
+ struct CmdReserveSpaceForCommandsInfoNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
+ uint32_t maxSequencesCount_ = 0 )
+ : objectTable( objectTable_ )
+ , indirectCommandsLayout( indirectCommandsLayout_ )
+ , maxSequencesCount( maxSequencesCount_ )
+ {}
+
+ CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
+ }
+
+ CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
+ const void* pNext = nullptr;
+ vk::ObjectTableNVX objectTable;
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
+ uint32_t maxSequencesCount;
+ };
+ static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CmdReserveSpaceForCommandsInfoNVX : public layout::CmdReserveSpaceForCommandsInfoNVX
+ {
+ VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(),
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(),
+ uint32_t maxSequencesCount_ = 0 )
+ : layout::CmdReserveSpaceForCommandsInfoNVX( objectTable_, indirectCommandsLayout_, maxSequencesCount_ )
{}
CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
- }
+ : layout::CmdReserveSpaceForCommandsInfoNVX( rhs )
+ {}
CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
+ layout::CmdReserveSpaceForCommandsInfoNVX::operator=(rhs);
return *this;
}
@@ -21711,13 +25051,13 @@
return *this;
}
- CmdReserveSpaceForCommandsInfoNVX & setObjectTable( ObjectTableNVX objectTable_ )
+ CmdReserveSpaceForCommandsInfoNVX & setObjectTable( vk::ObjectTableNVX objectTable_ )
{
objectTable = objectTable_;
return *this;
}
- CmdReserveSpaceForCommandsInfoNVX & setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
+ CmdReserveSpaceForCommandsInfoNVX & setIndirectCommandsLayout( vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ )
{
indirectCommandsLayout = indirectCommandsLayout_;
return *this;
@@ -21754,21 +25094,16 @@
}
private:
- StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
-
- public:
- const void* pNext = nullptr;
- ObjectTableNVX objectTable;
- IndirectCommandsLayoutNVX indirectCommandsLayout;
- uint32_t maxSequencesCount;
+ using layout::CmdReserveSpaceForCommandsInfoNVX::sType;
};
static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CmdReserveSpaceForCommandsInfoNVX>::value, "struct wrapper is not a standard layout!" );
struct CoarseSampleLocationNV
{
- CoarseSampleLocationNV( uint32_t pixelX_ = 0,
- uint32_t pixelY_ = 0,
- uint32_t sample_ = 0 )
+ VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( uint32_t pixelX_ = 0,
+ uint32_t pixelY_ = 0,
+ uint32_t sample_ = 0 )
: pixelX( pixelX_ )
, pixelY( pixelY_ )
, sample( sample_ )
@@ -21776,12 +25111,12 @@
CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs )
{
- memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+ *reinterpret_cast<VkCoarseSampleLocationNV*>(this) = rhs;
}
CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs )
{
- memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
+ *reinterpret_cast<VkCoarseSampleLocationNV*>(this) = rhs;
return *this;
}
@@ -21825,18 +25160,20 @@
return !operator==( rhs );
}
+ public:
uint32_t pixelX;
uint32_t pixelY;
uint32_t sample;
};
static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CoarseSampleLocationNV>::value, "struct wrapper is not a standard layout!" );
struct CoarseSampleOrderCustomNV
{
- CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations,
- uint32_t sampleCount_ = 0,
- uint32_t sampleLocationCount_ = 0,
- const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
+ VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( vk::ShadingRatePaletteEntryNV shadingRate_ = vk::ShadingRatePaletteEntryNV::eNoInvocations,
+ uint32_t sampleCount_ = 0,
+ uint32_t sampleLocationCount_ = 0,
+ const vk::CoarseSampleLocationNV* pSampleLocations_ = nullptr )
: shadingRate( shadingRate_ )
, sampleCount( sampleCount_ )
, sampleLocationCount( sampleLocationCount_ )
@@ -21845,16 +25182,16 @@
CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs )
{
- memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+ *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this) = rhs;
}
CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs )
{
- memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
+ *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this) = rhs;
return *this;
}
- CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ )
+ CoarseSampleOrderCustomNV & setShadingRate( vk::ShadingRatePaletteEntryNV shadingRate_ )
{
shadingRate = shadingRate_;
return *this;
@@ -21872,7 +25209,7 @@
return *this;
}
- CoarseSampleOrderCustomNV & setPSampleLocations( const CoarseSampleLocationNV* pSampleLocations_ )
+ CoarseSampleOrderCustomNV & setPSampleLocations( const vk::CoarseSampleLocationNV* pSampleLocations_ )
{
pSampleLocations = pSampleLocations_;
return *this;
@@ -21901,31 +25238,64 @@
return !operator==( rhs );
}
- ShadingRatePaletteEntryNV shadingRate;
+ public:
+ vk::ShadingRatePaletteEntryNV shadingRate;
uint32_t sampleCount;
uint32_t sampleLocationCount;
- const CoarseSampleLocationNV* pSampleLocations;
+ const vk::CoarseSampleLocationNV* pSampleLocations;
};
static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CoarseSampleOrderCustomNV>::value, "struct wrapper is not a standard layout!" );
- struct CommandBufferAllocateInfo
+ namespace layout
{
- CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(),
- CommandBufferLevel level_ = CommandBufferLevel::ePrimary,
- uint32_t commandBufferCount_ = 0 )
- : commandPool( commandPool_ )
- , level( level_ )
- , commandBufferCount( commandBufferCount_ )
+ struct CommandBufferAllocateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(),
+ vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary,
+ uint32_t commandBufferCount_ = 0 )
+ : commandPool( commandPool_ )
+ , level( level_ )
+ , commandBufferCount( commandBufferCount_ )
+ {}
+
+ CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferAllocateInfo*>(this) = rhs;
+ }
+
+ CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferAllocateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCommandBufferAllocateInfo;
+ const void* pNext = nullptr;
+ vk::CommandPool commandPool;
+ vk::CommandBufferLevel level;
+ uint32_t commandBufferCount;
+ };
+ static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CommandBufferAllocateInfo : public layout::CommandBufferAllocateInfo
+ {
+ VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(),
+ vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary,
+ uint32_t commandBufferCount_ = 0 )
+ : layout::CommandBufferAllocateInfo( commandPool_, level_, commandBufferCount_ )
{}
CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
- }
+ : layout::CommandBufferAllocateInfo( rhs )
+ {}
CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
+ layout::CommandBufferAllocateInfo::operator=(rhs);
return *this;
}
@@ -21935,13 +25305,13 @@
return *this;
}
- CommandBufferAllocateInfo & setCommandPool( CommandPool commandPool_ )
+ CommandBufferAllocateInfo & setCommandPool( vk::CommandPool commandPool_ )
{
commandPool = commandPool_;
return *this;
}
- CommandBufferAllocateInfo & setLevel( CommandBufferLevel level_ )
+ CommandBufferAllocateInfo & setLevel( vk::CommandBufferLevel level_ )
{
level = level_;
return *this;
@@ -21978,40 +25348,72 @@
}
private:
- StructureType sType = StructureType::eCommandBufferAllocateInfo;
-
- public:
- const void* pNext = nullptr;
- CommandPool commandPool;
- CommandBufferLevel level;
- uint32_t commandBufferCount;
+ using layout::CommandBufferAllocateInfo::sType;
};
static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CommandBufferAllocateInfo>::value, "struct wrapper is not a standard layout!" );
- struct CommandBufferInheritanceInfo
+ namespace layout
{
- CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(),
- uint32_t subpass_ = 0,
- Framebuffer framebuffer_ = Framebuffer(),
- Bool32 occlusionQueryEnable_ = 0,
- QueryControlFlags queryFlags_ = QueryControlFlags(),
- QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : renderPass( renderPass_ )
- , subpass( subpass_ )
- , framebuffer( framebuffer_ )
- , occlusionQueryEnable( occlusionQueryEnable_ )
- , queryFlags( queryFlags_ )
- , pipelineStatistics( pipelineStatistics_ )
+ struct CommandBufferInheritanceInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+ uint32_t subpass_ = 0,
+ vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+ vk::Bool32 occlusionQueryEnable_ = 0,
+ vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(),
+ vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+ : renderPass( renderPass_ )
+ , subpass( subpass_ )
+ , framebuffer( framebuffer_ )
+ , occlusionQueryEnable( occlusionQueryEnable_ )
+ , queryFlags( queryFlags_ )
+ , pipelineStatistics( pipelineStatistics_ )
+ {}
+
+ CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this) = rhs;
+ }
+
+ CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCommandBufferInheritanceInfo;
+ const void* pNext = nullptr;
+ vk::RenderPass renderPass;
+ uint32_t subpass;
+ vk::Framebuffer framebuffer;
+ vk::Bool32 occlusionQueryEnable;
+ vk::QueryControlFlags queryFlags;
+ vk::QueryPipelineStatisticFlags pipelineStatistics;
+ };
+ static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CommandBufferInheritanceInfo : public layout::CommandBufferInheritanceInfo
+ {
+ VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+ uint32_t subpass_ = 0,
+ vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+ vk::Bool32 occlusionQueryEnable_ = 0,
+ vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(),
+ vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+ : layout::CommandBufferInheritanceInfo( renderPass_, subpass_, framebuffer_, occlusionQueryEnable_, queryFlags_, pipelineStatistics_ )
{}
CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
- }
+ : layout::CommandBufferInheritanceInfo( rhs )
+ {}
CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
+ layout::CommandBufferInheritanceInfo::operator=(rhs);
return *this;
}
@@ -22021,7 +25423,7 @@
return *this;
}
- CommandBufferInheritanceInfo & setRenderPass( RenderPass renderPass_ )
+ CommandBufferInheritanceInfo & setRenderPass( vk::RenderPass renderPass_ )
{
renderPass = renderPass_;
return *this;
@@ -22033,25 +25435,25 @@
return *this;
}
- CommandBufferInheritanceInfo & setFramebuffer( Framebuffer framebuffer_ )
+ CommandBufferInheritanceInfo & setFramebuffer( vk::Framebuffer framebuffer_ )
{
framebuffer = framebuffer_;
return *this;
}
- CommandBufferInheritanceInfo & setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
+ CommandBufferInheritanceInfo & setOcclusionQueryEnable( vk::Bool32 occlusionQueryEnable_ )
{
occlusionQueryEnable = occlusionQueryEnable_;
return *this;
}
- CommandBufferInheritanceInfo & setQueryFlags( QueryControlFlags queryFlags_ )
+ CommandBufferInheritanceInfo & setQueryFlags( vk::QueryControlFlags queryFlags_ )
{
queryFlags = queryFlags_;
return *this;
}
- CommandBufferInheritanceInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+ CommandBufferInheritanceInfo & setPipelineStatistics( vk::QueryPipelineStatisticFlags pipelineStatistics_ )
{
pipelineStatistics = pipelineStatistics_;
return *this;
@@ -22085,35 +25487,56 @@
}
private:
- StructureType sType = StructureType::eCommandBufferInheritanceInfo;
-
- public:
- const void* pNext = nullptr;
- RenderPass renderPass;
- uint32_t subpass;
- Framebuffer framebuffer;
- Bool32 occlusionQueryEnable;
- QueryControlFlags queryFlags;
- QueryPipelineStatisticFlags pipelineStatistics;
+ using layout::CommandBufferInheritanceInfo::sType;
};
static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CommandBufferInheritanceInfo>::value, "struct wrapper is not a standard layout!" );
- struct CommandBufferBeginInfo
+ namespace layout
{
- CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(),
- const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
- : flags( flags_ )
- , pInheritanceInfo( pInheritanceInfo_ )
+ struct CommandBufferBeginInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(),
+ const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+ : flags( flags_ )
+ , pInheritanceInfo( pInheritanceInfo_ )
+ {}
+
+ CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferBeginInfo*>(this) = rhs;
+ }
+
+ CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferBeginInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCommandBufferBeginInfo;
+ const void* pNext = nullptr;
+ vk::CommandBufferUsageFlags flags;
+ const vk::CommandBufferInheritanceInfo* pInheritanceInfo;
+ };
+ static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CommandBufferBeginInfo : public layout::CommandBufferBeginInfo
+ {
+ VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(),
+ const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
+ : layout::CommandBufferBeginInfo( flags_, pInheritanceInfo_ )
{}
CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
- }
+ : layout::CommandBufferBeginInfo( rhs )
+ {}
CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
+ layout::CommandBufferBeginInfo::operator=(rhs);
return *this;
}
@@ -22123,13 +25546,13 @@
return *this;
}
- CommandBufferBeginInfo & setFlags( CommandBufferUsageFlags flags_ )
+ CommandBufferBeginInfo & setFlags( vk::CommandBufferUsageFlags flags_ )
{
flags = flags_;
return *this;
}
- CommandBufferBeginInfo & setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
+ CommandBufferBeginInfo & setPInheritanceInfo( const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ )
{
pInheritanceInfo = pInheritanceInfo_;
return *this;
@@ -22159,29 +25582,52 @@
}
private:
- StructureType sType = StructureType::eCommandBufferBeginInfo;
-
- public:
- const void* pNext = nullptr;
- CommandBufferUsageFlags flags;
- const CommandBufferInheritanceInfo* pInheritanceInfo;
+ using layout::CommandBufferBeginInfo::sType;
};
static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" );
- struct CommandBufferInheritanceConditionalRenderingInfoEXT
+ namespace layout
{
- CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = 0 )
- : conditionalRenderingEnable( conditionalRenderingEnable_ )
+ struct CommandBufferInheritanceConditionalRenderingInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 )
+ : conditionalRenderingEnable( conditionalRenderingEnable_ )
+ {}
+
+ CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
+ }
+
+ CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
+ const void* pNext = nullptr;
+ vk::Bool32 conditionalRenderingEnable;
+ };
+ static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CommandBufferInheritanceConditionalRenderingInfoEXT : public layout::CommandBufferInheritanceConditionalRenderingInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 )
+ : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( conditionalRenderingEnable_ )
{}
CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
- }
+ : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( rhs )
+ {}
CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) );
+ layout::CommandBufferInheritanceConditionalRenderingInfoEXT::operator=(rhs);
return *this;
}
@@ -22191,7 +25637,7 @@
return *this;
}
- CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ )
+ CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( vk::Bool32 conditionalRenderingEnable_ )
{
conditionalRenderingEnable = conditionalRenderingEnable_;
return *this;
@@ -22220,30 +25666,56 @@
}
private:
- StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Bool32 conditionalRenderingEnable;
+ using layout::CommandBufferInheritanceConditionalRenderingInfoEXT::sType;
};
static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CommandBufferInheritanceConditionalRenderingInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct CommandPoolCreateInfo
+ namespace layout
{
- CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(),
- uint32_t queueFamilyIndex_ = 0 )
- : flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
+ struct CommandPoolCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0 )
+ : flags( flags_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ {}
+
+ CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandPoolCreateInfo*>(this) = rhs;
+ }
+
+ CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkCommandPoolCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCommandPoolCreateInfo;
+ const void* pNext = nullptr;
+ vk::CommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ };
+ static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CommandPoolCreateInfo : public layout::CommandPoolCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0 )
+ : layout::CommandPoolCreateInfo( flags_, queueFamilyIndex_ )
{}
CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
- }
+ : layout::CommandPoolCreateInfo( rhs )
+ {}
CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
+ layout::CommandPoolCreateInfo::operator=(rhs);
return *this;
}
@@ -22253,7 +25725,7 @@
return *this;
}
- CommandPoolCreateInfo & setFlags( CommandPoolCreateFlags flags_ )
+ CommandPoolCreateInfo & setFlags( vk::CommandPoolCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -22289,20 +25761,16 @@
}
private:
- StructureType sType = StructureType::eCommandPoolCreateInfo;
-
- public:
- const void* pNext = nullptr;
- CommandPoolCreateFlags flags;
- uint32_t queueFamilyIndex;
+ using layout::CommandPoolCreateInfo::sType;
};
static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CommandPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct SpecializationMapEntry
{
- SpecializationMapEntry( uint32_t constantID_ = 0,
- uint32_t offset_ = 0,
- size_t size_ = 0 )
+ VULKAN_HPP_CONSTEXPR SpecializationMapEntry( uint32_t constantID_ = 0,
+ uint32_t offset_ = 0,
+ size_t size_ = 0 )
: constantID( constantID_ )
, offset( offset_ )
, size( size_ )
@@ -22310,12 +25778,12 @@
SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
{
- memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
+ *reinterpret_cast<VkSpecializationMapEntry*>(this) = rhs;
}
SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
{
- memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
+ *reinterpret_cast<VkSpecializationMapEntry*>(this) = rhs;
return *this;
}
@@ -22359,18 +25827,20 @@
return !operator==( rhs );
}
+ public:
uint32_t constantID;
uint32_t offset;
size_t size;
};
static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SpecializationMapEntry>::value, "struct wrapper is not a standard layout!" );
struct SpecializationInfo
{
- SpecializationInfo( uint32_t mapEntryCount_ = 0,
- const SpecializationMapEntry* pMapEntries_ = nullptr,
- size_t dataSize_ = 0,
- const void* pData_ = nullptr )
+ VULKAN_HPP_CONSTEXPR SpecializationInfo( uint32_t mapEntryCount_ = 0,
+ const vk::SpecializationMapEntry* pMapEntries_ = nullptr,
+ size_t dataSize_ = 0,
+ const void* pData_ = nullptr )
: mapEntryCount( mapEntryCount_ )
, pMapEntries( pMapEntries_ )
, dataSize( dataSize_ )
@@ -22379,12 +25849,12 @@
SpecializationInfo( VkSpecializationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SpecializationInfo ) );
+ *reinterpret_cast<VkSpecializationInfo*>(this) = rhs;
}
SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SpecializationInfo ) );
+ *reinterpret_cast<VkSpecializationInfo*>(this) = rhs;
return *this;
}
@@ -22394,7 +25864,7 @@
return *this;
}
- SpecializationInfo & setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
+ SpecializationInfo & setPMapEntries( const vk::SpecializationMapEntry* pMapEntries_ )
{
pMapEntries = pMapEntries_;
return *this;
@@ -22435,35 +25905,72 @@
return !operator==( rhs );
}
+ public:
uint32_t mapEntryCount;
- const SpecializationMapEntry* pMapEntries;
+ const vk::SpecializationMapEntry* pMapEntries;
size_t dataSize;
const void* pData;
};
static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SpecializationInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineShaderStageCreateInfo
+ namespace layout
{
- PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(),
- ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex,
- ShaderModule module_ = ShaderModule(),
- const char* pName_ = nullptr,
- const SpecializationInfo* pSpecializationInfo_ = nullptr )
- : flags( flags_ )
- , stage( stage_ )
- , module( module_ )
- , pName( pName_ )
- , pSpecializationInfo( pSpecializationInfo_ )
+ struct PipelineShaderStageCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(),
+ vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex,
+ vk::ShaderModule module_ = vk::ShaderModule(),
+ const char* pName_ = nullptr,
+ const vk::SpecializationInfo* pSpecializationInfo_ = nullptr )
+ : flags( flags_ )
+ , stage( stage_ )
+ , module( module_ )
+ , pName( pName_ )
+ , pSpecializationInfo( pSpecializationInfo_ )
+ {}
+
+ PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this) = rhs;
+ }
+
+ PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineShaderStageCreateFlags flags;
+ vk::ShaderStageFlagBits stage;
+ vk::ShaderModule module;
+ const char* pName;
+ const vk::SpecializationInfo* pSpecializationInfo;
+ };
+ static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineShaderStageCreateInfo : public layout::PipelineShaderStageCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(),
+ vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex,
+ vk::ShaderModule module_ = vk::ShaderModule(),
+ const char* pName_ = nullptr,
+ const vk::SpecializationInfo* pSpecializationInfo_ = nullptr )
+ : layout::PipelineShaderStageCreateInfo( flags_, stage_, module_, pName_, pSpecializationInfo_ )
{}
PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
- }
+ : layout::PipelineShaderStageCreateInfo( rhs )
+ {}
PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
+ layout::PipelineShaderStageCreateInfo::operator=(rhs);
return *this;
}
@@ -22473,19 +25980,19 @@
return *this;
}
- PipelineShaderStageCreateInfo & setFlags( PipelineShaderStageCreateFlags flags_ )
+ PipelineShaderStageCreateInfo & setFlags( vk::PipelineShaderStageCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineShaderStageCreateInfo & setStage( ShaderStageFlagBits stage_ )
+ PipelineShaderStageCreateInfo & setStage( vk::ShaderStageFlagBits stage_ )
{
stage = stage_;
return *this;
}
- PipelineShaderStageCreateInfo & setModule( ShaderModule module_ )
+ PipelineShaderStageCreateInfo & setModule( vk::ShaderModule module_ )
{
module = module_;
return *this;
@@ -22497,7 +26004,7 @@
return *this;
}
- PipelineShaderStageCreateInfo & setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
+ PipelineShaderStageCreateInfo & setPSpecializationInfo( const vk::SpecializationInfo* pSpecializationInfo_ )
{
pSpecializationInfo = pSpecializationInfo_;
return *this;
@@ -22530,40 +26037,68 @@
}
private:
- StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineShaderStageCreateFlags flags;
- ShaderStageFlagBits stage;
- ShaderModule module;
- const char* pName;
- const SpecializationInfo* pSpecializationInfo;
+ using layout::PipelineShaderStageCreateInfo::sType;
};
static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineShaderStageCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ComputePipelineCreateInfo
+ namespace layout
{
- ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(),
- PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(),
- PipelineLayout layout_ = PipelineLayout(),
- Pipeline basePipelineHandle_ = Pipeline(),
- int32_t basePipelineIndex_ = 0 )
- : flags( flags_ )
- , stage( stage_ )
- , layout( layout_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
+ struct ComputePipelineCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+ vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(),
+ vk::PipelineLayout layout_ = vk::PipelineLayout(),
+ vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : flags( flags_ )
+ , stage( stage_ )
+ , layout( layout_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
+ {}
+
+ ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkComputePipelineCreateInfo*>(this) = rhs;
+ }
+
+ ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkComputePipelineCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eComputePipelineCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineCreateFlags flags;
+ vk::PipelineShaderStageCreateInfo stage;
+ vk::PipelineLayout layout;
+ vk::Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ };
+ static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ComputePipelineCreateInfo : public layout::ComputePipelineCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+ vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(),
+ vk::PipelineLayout layout_ = vk::PipelineLayout(),
+ vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : layout::ComputePipelineCreateInfo( flags_, stage_, layout_, basePipelineHandle_, basePipelineIndex_ )
{}
ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
- }
+ : layout::ComputePipelineCreateInfo( rhs )
+ {}
ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
+ layout::ComputePipelineCreateInfo::operator=(rhs);
return *this;
}
@@ -22573,25 +26108,25 @@
return *this;
}
- ComputePipelineCreateInfo & setFlags( PipelineCreateFlags flags_ )
+ ComputePipelineCreateInfo & setFlags( vk::PipelineCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- ComputePipelineCreateInfo & setStage( PipelineShaderStageCreateInfo stage_ )
+ ComputePipelineCreateInfo & setStage( vk::PipelineShaderStageCreateInfo stage_ )
{
stage = stage_;
return *this;
}
- ComputePipelineCreateInfo & setLayout( PipelineLayout layout_ )
+ ComputePipelineCreateInfo & setLayout( vk::PipelineLayout layout_ )
{
layout = layout_;
return *this;
}
- ComputePipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ ComputePipelineCreateInfo & setBasePipelineHandle( vk::Pipeline basePipelineHandle_ )
{
basePipelineHandle = basePipelineHandle_;
return *this;
@@ -22630,36 +26165,60 @@
}
private:
- StructureType sType = StructureType::eComputePipelineCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineCreateFlags flags;
- PipelineShaderStageCreateInfo stage;
- PipelineLayout layout;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
+ using layout::ComputePipelineCreateInfo::sType;
};
static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ComputePipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ConditionalRenderingBeginInfoEXT
+ namespace layout
{
- ConditionalRenderingBeginInfoEXT( Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0,
- ConditionalRenderingFlagsEXT flags_ = ConditionalRenderingFlagsEXT() )
- : buffer( buffer_ )
- , offset( offset_ )
- , flags( flags_ )
+ struct ConditionalRenderingBeginInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceSize offset_ = 0,
+ vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() )
+ : buffer( buffer_ )
+ , offset( offset_ )
+ , flags( flags_ )
+ {}
+
+ ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
+ }
+
+ ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
+ const void* pNext = nullptr;
+ vk::Buffer buffer;
+ vk::DeviceSize offset;
+ vk::ConditionalRenderingFlagsEXT flags;
+ };
+ static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ConditionalRenderingBeginInfoEXT : public layout::ConditionalRenderingBeginInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceSize offset_ = 0,
+ vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() )
+ : layout::ConditionalRenderingBeginInfoEXT( buffer_, offset_, flags_ )
{}
ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
- }
+ : layout::ConditionalRenderingBeginInfoEXT( rhs )
+ {}
ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
+ layout::ConditionalRenderingBeginInfoEXT::operator=(rhs);
return *this;
}
@@ -22669,19 +26228,19 @@
return *this;
}
- ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ )
+ ConditionalRenderingBeginInfoEXT & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ )
+ ConditionalRenderingBeginInfoEXT & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
}
- ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ )
+ ConditionalRenderingBeginInfoEXT & setFlags( vk::ConditionalRenderingFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -22712,22 +26271,17 @@
}
private:
- StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Buffer buffer;
- DeviceSize offset;
- ConditionalRenderingFlagsEXT flags;
+ using layout::ConditionalRenderingBeginInfoEXT::sType;
};
static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ConditionalRenderingBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
struct ConformanceVersionKHR
{
- ConformanceVersionKHR( uint8_t major_ = 0,
- uint8_t minor_ = 0,
- uint8_t subminor_ = 0,
- uint8_t patch_ = 0 )
+ VULKAN_HPP_CONSTEXPR ConformanceVersionKHR( uint8_t major_ = 0,
+ uint8_t minor_ = 0,
+ uint8_t subminor_ = 0,
+ uint8_t patch_ = 0 )
: major( major_ )
, minor( minor_ )
, subminor( subminor_ )
@@ -22736,12 +26290,12 @@
ConformanceVersionKHR( VkConformanceVersionKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
+ *reinterpret_cast<VkConformanceVersionKHR*>(this) = rhs;
}
ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
+ *reinterpret_cast<VkConformanceVersionKHR*>(this) = rhs;
return *this;
}
@@ -22792,41 +26346,84 @@
return !operator==( rhs );
}
+ public:
uint8_t major;
uint8_t minor;
uint8_t subminor;
uint8_t patch;
};
static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ConformanceVersionKHR>::value, "struct wrapper is not a standard layout!" );
- struct CooperativeMatrixPropertiesNV
+ namespace layout
{
- CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0,
- uint32_t NSize_ = 0,
- uint32_t KSize_ = 0,
- ComponentTypeNV AType_ = ComponentTypeNV::eFloat16,
- ComponentTypeNV BType_ = ComponentTypeNV::eFloat16,
- ComponentTypeNV CType_ = ComponentTypeNV::eFloat16,
- ComponentTypeNV DType_ = ComponentTypeNV::eFloat16,
- ScopeNV scope_ = ScopeNV::eDevice )
- : MSize( MSize_ )
- , NSize( NSize_ )
- , KSize( KSize_ )
- , AType( AType_ )
- , BType( BType_ )
- , CType( CType_ )
- , DType( DType_ )
- , scope( scope_ )
+ struct CooperativeMatrixPropertiesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0,
+ uint32_t NSize_ = 0,
+ uint32_t KSize_ = 0,
+ vk::ComponentTypeNV AType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ComponentTypeNV BType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ScopeNV scope_ = vk::ScopeNV::eDevice )
+ : MSize( MSize_ )
+ , NSize( NSize_ )
+ , KSize( KSize_ )
+ , AType( AType_ )
+ , BType( BType_ )
+ , CType( CType_ )
+ , DType( DType_ )
+ , scope( scope_ )
+ {}
+
+ CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
+ }
+
+ CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV;
+ void* pNext = nullptr;
+ uint32_t MSize;
+ uint32_t NSize;
+ uint32_t KSize;
+ vk::ComponentTypeNV AType;
+ vk::ComponentTypeNV BType;
+ vk::ComponentTypeNV CType;
+ vk::ComponentTypeNV DType;
+ vk::ScopeNV scope;
+ };
+ static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CooperativeMatrixPropertiesNV : public layout::CooperativeMatrixPropertiesNV
+ {
+ VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0,
+ uint32_t NSize_ = 0,
+ uint32_t KSize_ = 0,
+ vk::ComponentTypeNV AType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ComponentTypeNV BType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16,
+ vk::ScopeNV scope_ = vk::ScopeNV::eDevice )
+ : layout::CooperativeMatrixPropertiesNV( MSize_, NSize_, KSize_, AType_, BType_, CType_, DType_, scope_ )
{}
CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( CooperativeMatrixPropertiesNV ) );
- }
+ : layout::CooperativeMatrixPropertiesNV( rhs )
+ {}
CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( CooperativeMatrixPropertiesNV ) );
+ layout::CooperativeMatrixPropertiesNV::operator=(rhs);
return *this;
}
@@ -22854,31 +26451,31 @@
return *this;
}
- CooperativeMatrixPropertiesNV & setAType( ComponentTypeNV AType_ )
+ CooperativeMatrixPropertiesNV & setAType( vk::ComponentTypeNV AType_ )
{
AType = AType_;
return *this;
}
- CooperativeMatrixPropertiesNV & setBType( ComponentTypeNV BType_ )
+ CooperativeMatrixPropertiesNV & setBType( vk::ComponentTypeNV BType_ )
{
BType = BType_;
return *this;
}
- CooperativeMatrixPropertiesNV & setCType( ComponentTypeNV CType_ )
+ CooperativeMatrixPropertiesNV & setCType( vk::ComponentTypeNV CType_ )
{
CType = CType_;
return *this;
}
- CooperativeMatrixPropertiesNV & setDType( ComponentTypeNV DType_ )
+ CooperativeMatrixPropertiesNV & setDType( vk::ComponentTypeNV DType_ )
{
DType = DType_;
return *this;
}
- CooperativeMatrixPropertiesNV & setScope( ScopeNV scope_ )
+ CooperativeMatrixPropertiesNV & setScope( vk::ScopeNV scope_ )
{
scope = scope_;
return *this;
@@ -22914,47 +26511,76 @@
}
private:
- StructureType sType = StructureType::eCooperativeMatrixPropertiesNV;
-
- public:
- void* pNext = nullptr;
- uint32_t MSize;
- uint32_t NSize;
- uint32_t KSize;
- ComponentTypeNV AType;
- ComponentTypeNV BType;
- ComponentTypeNV CType;
- ComponentTypeNV DType;
- ScopeNV scope;
+ using layout::CooperativeMatrixPropertiesNV::sType;
};
static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct CopyDescriptorSet
+ namespace layout
{
- 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 )
- : srcSet( srcSet_ )
- , srcBinding( srcBinding_ )
- , srcArrayElement( srcArrayElement_ )
- , dstSet( dstSet_ )
- , dstBinding( dstBinding_ )
- , dstArrayElement( dstArrayElement_ )
- , descriptorCount( descriptorCount_ )
+ struct CopyDescriptorSet
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(),
+ uint32_t srcBinding_ = 0,
+ uint32_t srcArrayElement_ = 0,
+ vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
+ uint32_t dstBinding_ = 0,
+ uint32_t dstArrayElement_ = 0,
+ uint32_t descriptorCount_ = 0 )
+ : srcSet( srcSet_ )
+ , srcBinding( srcBinding_ )
+ , srcArrayElement( srcArrayElement_ )
+ , dstSet( dstSet_ )
+ , dstBinding( dstBinding_ )
+ , dstArrayElement( dstArrayElement_ )
+ , descriptorCount( descriptorCount_ )
+ {}
+
+ CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
+ {
+ *reinterpret_cast<VkCopyDescriptorSet*>(this) = rhs;
+ }
+
+ CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
+ {
+ *reinterpret_cast<VkCopyDescriptorSet*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eCopyDescriptorSet;
+ const void* pNext = nullptr;
+ vk::DescriptorSet srcSet;
+ uint32_t srcBinding;
+ uint32_t srcArrayElement;
+ vk::DescriptorSet dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ };
+ static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "layout struct and wrapper have different size!" );
+ }
+
+ struct CopyDescriptorSet : public layout::CopyDescriptorSet
+ {
+ VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(),
+ uint32_t srcBinding_ = 0,
+ uint32_t srcArrayElement_ = 0,
+ vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
+ uint32_t dstBinding_ = 0,
+ uint32_t dstArrayElement_ = 0,
+ uint32_t descriptorCount_ = 0 )
+ : layout::CopyDescriptorSet( srcSet_, srcBinding_, srcArrayElement_, dstSet_, dstBinding_, dstArrayElement_, descriptorCount_ )
{}
CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
- {
- memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
- }
+ : layout::CopyDescriptorSet( rhs )
+ {}
CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
{
- memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
+ layout::CopyDescriptorSet::operator=(rhs);
return *this;
}
@@ -22964,7 +26590,7 @@
return *this;
}
- CopyDescriptorSet & setSrcSet( DescriptorSet srcSet_ )
+ CopyDescriptorSet & setSrcSet( vk::DescriptorSet srcSet_ )
{
srcSet = srcSet_;
return *this;
@@ -22982,7 +26608,7 @@
return *this;
}
- CopyDescriptorSet & setDstSet( DescriptorSet dstSet_ )
+ CopyDescriptorSet & setDstSet( vk::DescriptorSet dstSet_ )
{
dstSet = dstSet_;
return *this;
@@ -23035,41 +26661,66 @@
}
private:
- StructureType sType = StructureType::eCopyDescriptorSet;
-
- public:
- const void* pNext = nullptr;
- DescriptorSet srcSet;
- uint32_t srcBinding;
- uint32_t srcArrayElement;
- DescriptorSet dstSet;
- uint32_t dstBinding;
- uint32_t dstArrayElement;
- uint32_t descriptorCount;
+ using layout::CopyDescriptorSet::sType;
};
static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<CopyDescriptorSet>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct D3D12FenceSubmitInfoKHR
+
+ namespace layout
{
- D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
- const uint64_t* pWaitSemaphoreValues_ = nullptr,
- uint32_t signalSemaphoreValuesCount_ = 0,
- const uint64_t* pSignalSemaphoreValues_ = nullptr )
- : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
- , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
- , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
- , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+ struct D3D12FenceSubmitInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
+ const uint64_t* pWaitSemaphoreValues_ = nullptr,
+ uint32_t signalSemaphoreValuesCount_ = 0,
+ const uint64_t* pSignalSemaphoreValues_ = nullptr )
+ : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+ , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+ , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
+ , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+ {}
+
+ D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
+ }
+
+ D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreValuesCount;
+ const uint64_t* pWaitSemaphoreValues;
+ uint32_t signalSemaphoreValuesCount;
+ const uint64_t* pSignalSemaphoreValues;
+ };
+ static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct D3D12FenceSubmitInfoKHR : public layout::D3D12FenceSubmitInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
+ const uint64_t* pWaitSemaphoreValues_ = nullptr,
+ uint32_t signalSemaphoreValuesCount_ = 0,
+ const uint64_t* pSignalSemaphoreValues_ = nullptr )
+ : layout::D3D12FenceSubmitInfoKHR( waitSemaphoreValuesCount_, pWaitSemaphoreValues_, signalSemaphoreValuesCount_, pSignalSemaphoreValues_ )
{}
D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
- }
+ : layout::D3D12FenceSubmitInfoKHR( rhs )
+ {}
D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
+ layout::D3D12FenceSubmitInfoKHR::operator=(rhs);
return *this;
}
@@ -23129,35 +26780,59 @@
}
private:
- StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t waitSemaphoreValuesCount;
- const uint64_t* pWaitSemaphoreValues;
- uint32_t signalSemaphoreValuesCount;
- const uint64_t* pSignalSemaphoreValues;
+ using layout::D3D12FenceSubmitInfoKHR::sType;
};
static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<D3D12FenceSubmitInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct DebugMarkerMarkerInfoEXT
+ namespace layout
{
- DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
- std::array<float,4> const& color_ = { { 0 } } )
- : pMarkerName( pMarkerName_ )
+ struct DebugMarkerMarkerInfoEXT
{
- memcpy( &color, color_.data(), 4 * sizeof( float ) );
- }
+ protected:
+ VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
+ std::array<float,4> const& color_ = { { 0 } } )
+ : pMarkerName( pMarkerName_ )
+ , color{}
+ {
+ vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
+ }
+
+ DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
+ }
+
+ DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
+ const void* pNext = nullptr;
+ const char* pMarkerName;
+ float color[4];
+ };
+ static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugMarkerMarkerInfoEXT : public layout::DebugMarkerMarkerInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
+ std::array<float,4> const& color_ = { { 0 } } )
+ : layout::DebugMarkerMarkerInfoEXT( pMarkerName_, color_ )
+ {}
DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
- }
+ : layout::DebugMarkerMarkerInfoEXT( rhs )
+ {}
DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
+ layout::DebugMarkerMarkerInfoEXT::operator=(rhs);
return *this;
}
@@ -23203,33 +26878,60 @@
}
private:
- StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
-
- public:
- const void* pNext = nullptr;
- const char* pMarkerName;
- float color[4];
+ using layout::DebugMarkerMarkerInfoEXT::sType;
};
static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugMarkerMarkerInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugMarkerObjectNameInfoEXT
+ namespace layout
{
- DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
- uint64_t object_ = 0,
- const char* pObjectName_ = nullptr )
- : objectType( objectType_ )
- , object( object_ )
- , pObjectName( pObjectName_ )
+ struct DebugMarkerObjectNameInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
+ uint64_t object_ = 0,
+ const char* pObjectName_ = nullptr )
+ : objectType( objectType_ )
+ , object( object_ )
+ , pObjectName( pObjectName_ )
+ {}
+
+ DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
+ }
+
+ DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
+ const void* pNext = nullptr;
+ vk::DebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ const char* pObjectName;
+ };
+ static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugMarkerObjectNameInfoEXT : public layout::DebugMarkerObjectNameInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
+ uint64_t object_ = 0,
+ const char* pObjectName_ = nullptr )
+ : layout::DebugMarkerObjectNameInfoEXT( objectType_, object_, pObjectName_ )
{}
DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
- }
+ : layout::DebugMarkerObjectNameInfoEXT( rhs )
+ {}
DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
+ layout::DebugMarkerObjectNameInfoEXT::operator=(rhs);
return *this;
}
@@ -23239,7 +26941,7 @@
return *this;
}
- DebugMarkerObjectNameInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ )
+ DebugMarkerObjectNameInfoEXT & setObjectType( vk::DebugReportObjectTypeEXT objectType_ )
{
objectType = objectType_;
return *this;
@@ -23282,38 +26984,68 @@
}
private:
- StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DebugReportObjectTypeEXT objectType;
- uint64_t object;
- const char* pObjectName;
+ using layout::DebugMarkerObjectNameInfoEXT::sType;
};
static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugMarkerObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugMarkerObjectTagInfoEXT
+ namespace layout
{
- DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown,
- uint64_t object_ = 0,
- uint64_t tagName_ = 0,
- size_t tagSize_ = 0,
- const void* pTag_ = nullptr )
- : objectType( objectType_ )
- , object( object_ )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
+ struct DebugMarkerObjectTagInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
+ uint64_t object_ = 0,
+ uint64_t tagName_ = 0,
+ size_t tagSize_ = 0,
+ const void* pTag_ = nullptr )
+ : objectType( objectType_ )
+ , object( object_ )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
+ {}
+
+ DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
+ }
+
+ DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
+ const void* pNext = nullptr;
+ vk::DebugReportObjectTypeEXT objectType;
+ uint64_t object;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
+ };
+ static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugMarkerObjectTagInfoEXT : public layout::DebugMarkerObjectTagInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown,
+ uint64_t object_ = 0,
+ uint64_t tagName_ = 0,
+ size_t tagSize_ = 0,
+ const void* pTag_ = nullptr )
+ : layout::DebugMarkerObjectTagInfoEXT( objectType_, object_, tagName_, tagSize_, pTag_ )
{}
DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
- }
+ : layout::DebugMarkerObjectTagInfoEXT( rhs )
+ {}
DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
+ layout::DebugMarkerObjectTagInfoEXT::operator=(rhs);
return *this;
}
@@ -23323,7 +27055,7 @@
return *this;
}
- DebugMarkerObjectTagInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ )
+ DebugMarkerObjectTagInfoEXT & setObjectType( vk::DebugReportObjectTypeEXT objectType_ )
{
objectType = objectType_;
return *this;
@@ -23380,36 +27112,60 @@
}
private:
- StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DebugReportObjectTypeEXT objectType;
- uint64_t object;
- uint64_t tagName;
- size_t tagSize;
- const void* pTag;
+ using layout::DebugMarkerObjectTagInfoEXT::sType;
};
static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugMarkerObjectTagInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugReportCallbackCreateInfoEXT
+ namespace layout
{
- DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(),
- PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
- void* pUserData_ = nullptr )
- : flags( flags_ )
- , pfnCallback( pfnCallback_ )
- , pUserData( pUserData_ )
+ struct DebugReportCallbackCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(),
+ PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
+ void* pUserData_ = nullptr )
+ : flags( flags_ )
+ , pfnCallback( pfnCallback_ )
+ , pUserData( pUserData_ )
+ {}
+
+ DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
+ }
+
+ DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::DebugReportFlagsEXT flags;
+ PFN_vkDebugReportCallbackEXT pfnCallback;
+ void* pUserData;
+ };
+ static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugReportCallbackCreateInfoEXT : public layout::DebugReportCallbackCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(),
+ PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
+ void* pUserData_ = nullptr )
+ : layout::DebugReportCallbackCreateInfoEXT( flags_, pfnCallback_, pUserData_ )
{}
DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
- }
+ : layout::DebugReportCallbackCreateInfoEXT( rhs )
+ {}
DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
+ layout::DebugReportCallbackCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -23419,7 +27175,7 @@
return *this;
}
- DebugReportCallbackCreateInfoEXT & setFlags( DebugReportFlagsEXT flags_ )
+ DebugReportCallbackCreateInfoEXT & setFlags( vk::DebugReportFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -23462,33 +27218,58 @@
}
private:
- StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DebugReportFlagsEXT flags;
- PFN_vkDebugReportCallbackEXT pfnCallback;
- void* pUserData;
+ using layout::DebugReportCallbackCreateInfoEXT::sType;
};
static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugReportCallbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugUtilsLabelEXT
+ namespace layout
{
- DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
- std::array<float,4> const& color_ = { { 0 } } )
- : pLabelName( pLabelName_ )
+ struct DebugUtilsLabelEXT
{
- memcpy( &color, color_.data(), 4 * sizeof( float ) );
- }
+ protected:
+ VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
+ std::array<float,4> const& color_ = { { 0 } } )
+ : pLabelName( pLabelName_ )
+ , color{}
+ {
+ vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
+ }
+
+ DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
+ }
+
+ DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugUtilsLabelEXT;
+ const void* pNext = nullptr;
+ const char* pLabelName;
+ float color[4];
+ };
+ static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugUtilsLabelEXT : public layout::DebugUtilsLabelEXT
+ {
+ VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
+ std::array<float,4> const& color_ = { { 0 } } )
+ : layout::DebugUtilsLabelEXT( pLabelName_, color_ )
+ {}
DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
- }
+ : layout::DebugUtilsLabelEXT( rhs )
+ {}
DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
+ layout::DebugUtilsLabelEXT::operator=(rhs);
return *this;
}
@@ -23534,33 +27315,60 @@
}
private:
- StructureType sType = StructureType::eDebugUtilsLabelEXT;
-
- public:
- const void* pNext = nullptr;
- const char* pLabelName;
- float color[4];
+ using layout::DebugUtilsLabelEXT::sType;
};
static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugUtilsLabelEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugUtilsObjectNameInfoEXT
+ namespace layout
{
- DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
- uint64_t objectHandle_ = 0,
- const char* pObjectName_ = nullptr )
- : objectType( objectType_ )
- , objectHandle( objectHandle_ )
- , pObjectName( pObjectName_ )
+ struct DebugUtilsObjectNameInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
+ uint64_t objectHandle_ = 0,
+ const char* pObjectName_ = nullptr )
+ : objectType( objectType_ )
+ , objectHandle( objectHandle_ )
+ , pObjectName( pObjectName_ )
+ {}
+
+ DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
+ }
+
+ DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
+ const void* pNext = nullptr;
+ vk::ObjectType objectType;
+ uint64_t objectHandle;
+ const char* pObjectName;
+ };
+ static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugUtilsObjectNameInfoEXT : public layout::DebugUtilsObjectNameInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
+ uint64_t objectHandle_ = 0,
+ const char* pObjectName_ = nullptr )
+ : layout::DebugUtilsObjectNameInfoEXT( objectType_, objectHandle_, pObjectName_ )
{}
DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
- }
+ : layout::DebugUtilsObjectNameInfoEXT( rhs )
+ {}
DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
+ layout::DebugUtilsObjectNameInfoEXT::operator=(rhs);
return *this;
}
@@ -23570,7 +27378,7 @@
return *this;
}
- DebugUtilsObjectNameInfoEXT & setObjectType( ObjectType objectType_ )
+ DebugUtilsObjectNameInfoEXT & setObjectType( vk::ObjectType objectType_ )
{
objectType = objectType_;
return *this;
@@ -23613,48 +27421,88 @@
}
private:
- StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT;
-
- public:
- const void* pNext = nullptr;
- ObjectType objectType;
- uint64_t objectHandle;
- const char* pObjectName;
+ using layout::DebugUtilsObjectNameInfoEXT::sType;
};
static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugUtilsObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugUtilsMessengerCallbackDataEXT
+ namespace layout
{
- DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = DebugUtilsMessengerCallbackDataFlagsEXT(),
- const char* pMessageIdName_ = nullptr,
- int32_t messageIdNumber_ = 0,
- const char* pMessage_ = nullptr,
- uint32_t queueLabelCount_ = 0,
- const DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
- uint32_t cmdBufLabelCount_ = 0,
- const DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
- uint32_t objectCount_ = 0,
- const DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
- : flags( flags_ )
- , pMessageIdName( pMessageIdName_ )
- , messageIdNumber( messageIdNumber_ )
- , pMessage( pMessage_ )
- , queueLabelCount( queueLabelCount_ )
- , pQueueLabels( pQueueLabels_ )
- , cmdBufLabelCount( cmdBufLabelCount_ )
- , pCmdBufLabels( pCmdBufLabels_ )
- , objectCount( objectCount_ )
- , pObjects( pObjects_ )
+ struct DebugUtilsMessengerCallbackDataEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(),
+ const char* pMessageIdName_ = nullptr,
+ int32_t messageIdNumber_ = 0,
+ const char* pMessage_ = nullptr,
+ uint32_t queueLabelCount_ = 0,
+ const vk::DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
+ uint32_t cmdBufLabelCount_ = 0,
+ const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
+ uint32_t objectCount_ = 0,
+ const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
+ : flags( flags_ )
+ , pMessageIdName( pMessageIdName_ )
+ , messageIdNumber( messageIdNumber_ )
+ , pMessage( pMessage_ )
+ , queueLabelCount( queueLabelCount_ )
+ , pQueueLabels( pQueueLabels_ )
+ , cmdBufLabelCount( cmdBufLabelCount_ )
+ , pCmdBufLabels( pCmdBufLabels_ )
+ , objectCount( objectCount_ )
+ , pObjects( pObjects_ )
+ {}
+
+ DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
+ }
+
+ DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
+ const void* pNext = nullptr;
+ vk::DebugUtilsMessengerCallbackDataFlagsEXT flags;
+ const char* pMessageIdName;
+ int32_t messageIdNumber;
+ const char* pMessage;
+ uint32_t queueLabelCount;
+ const vk::DebugUtilsLabelEXT* pQueueLabels;
+ uint32_t cmdBufLabelCount;
+ const vk::DebugUtilsLabelEXT* pCmdBufLabels;
+ uint32_t objectCount;
+ const vk::DebugUtilsObjectNameInfoEXT* pObjects;
+ };
+ static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugUtilsMessengerCallbackDataEXT : public layout::DebugUtilsMessengerCallbackDataEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(),
+ const char* pMessageIdName_ = nullptr,
+ int32_t messageIdNumber_ = 0,
+ const char* pMessage_ = nullptr,
+ uint32_t queueLabelCount_ = 0,
+ const vk::DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
+ uint32_t cmdBufLabelCount_ = 0,
+ const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
+ uint32_t objectCount_ = 0,
+ const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
+ : layout::DebugUtilsMessengerCallbackDataEXT( flags_, pMessageIdName_, messageIdNumber_, pMessage_, queueLabelCount_, pQueueLabels_, cmdBufLabelCount_, pCmdBufLabels_, objectCount_, pObjects_ )
{}
DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
- }
+ : layout::DebugUtilsMessengerCallbackDataEXT( rhs )
+ {}
DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
+ layout::DebugUtilsMessengerCallbackDataEXT::operator=(rhs);
return *this;
}
@@ -23664,7 +27512,7 @@
return *this;
}
- DebugUtilsMessengerCallbackDataEXT & setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
+ DebugUtilsMessengerCallbackDataEXT & setFlags( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -23694,7 +27542,7 @@
return *this;
}
- DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( const DebugUtilsLabelEXT* pQueueLabels_ )
+ DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( const vk::DebugUtilsLabelEXT* pQueueLabels_ )
{
pQueueLabels = pQueueLabels_;
return *this;
@@ -23706,7 +27554,7 @@
return *this;
}
- DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const DebugUtilsLabelEXT* pCmdBufLabels_ )
+ DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const vk::DebugUtilsLabelEXT* pCmdBufLabels_ )
{
pCmdBufLabels = pCmdBufLabels_;
return *this;
@@ -23718,7 +27566,7 @@
return *this;
}
- DebugUtilsMessengerCallbackDataEXT & setPObjects( const DebugUtilsObjectNameInfoEXT* pObjects_ )
+ DebugUtilsMessengerCallbackDataEXT & setPObjects( const vk::DebugUtilsObjectNameInfoEXT* pObjects_ )
{
pObjects = pObjects_;
return *this;
@@ -23756,45 +27604,68 @@
}
private:
- StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT;
-
- public:
- const void* pNext = nullptr;
- DebugUtilsMessengerCallbackDataFlagsEXT flags;
- const char* pMessageIdName;
- int32_t messageIdNumber;
- const char* pMessage;
- uint32_t queueLabelCount;
- const DebugUtilsLabelEXT* pQueueLabels;
- uint32_t cmdBufLabelCount;
- const DebugUtilsLabelEXT* pCmdBufLabels;
- uint32_t objectCount;
- const DebugUtilsObjectNameInfoEXT* pObjects;
+ using layout::DebugUtilsMessengerCallbackDataEXT::sType;
};
static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugUtilsMessengerCallbackDataEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugUtilsMessengerCreateInfoEXT
+ namespace layout
{
- DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = DebugUtilsMessengerCreateFlagsEXT(),
- DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = DebugUtilsMessageSeverityFlagsEXT(),
- DebugUtilsMessageTypeFlagsEXT messageType_ = DebugUtilsMessageTypeFlagsEXT(),
- PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
- void* pUserData_ = nullptr )
- : flags( flags_ )
- , messageSeverity( messageSeverity_ )
- , messageType( messageType_ )
- , pfnUserCallback( pfnUserCallback_ )
- , pUserData( pUserData_ )
+ struct DebugUtilsMessengerCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(),
+ vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(),
+ vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(),
+ PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
+ void* pUserData_ = nullptr )
+ : flags( flags_ )
+ , messageSeverity( messageSeverity_ )
+ , messageType( messageType_ )
+ , pfnUserCallback( pfnUserCallback_ )
+ , pUserData( pUserData_ )
+ {}
+
+ DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
+ }
+
+ DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::DebugUtilsMessengerCreateFlagsEXT flags;
+ vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity;
+ vk::DebugUtilsMessageTypeFlagsEXT messageType;
+ PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
+ void* pUserData;
+ };
+ static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugUtilsMessengerCreateInfoEXT : public layout::DebugUtilsMessengerCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(),
+ vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(),
+ vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(),
+ PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
+ void* pUserData_ = nullptr )
+ : layout::DebugUtilsMessengerCreateInfoEXT( flags_, messageSeverity_, messageType_, pfnUserCallback_, pUserData_ )
{}
DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
- }
+ : layout::DebugUtilsMessengerCreateInfoEXT( rhs )
+ {}
DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
+ layout::DebugUtilsMessengerCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -23804,19 +27675,19 @@
return *this;
}
- DebugUtilsMessengerCreateInfoEXT & setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ )
+ DebugUtilsMessengerCreateInfoEXT & setFlags( vk::DebugUtilsMessengerCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
+ DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ )
{
messageSeverity = messageSeverity_;
return *this;
}
- DebugUtilsMessengerCreateInfoEXT & setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ )
+ DebugUtilsMessengerCreateInfoEXT & setMessageType( vk::DebugUtilsMessageTypeFlagsEXT messageType_ )
{
messageType = messageType_;
return *this;
@@ -23861,40 +27732,68 @@
}
private:
- StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DebugUtilsMessengerCreateFlagsEXT flags;
- DebugUtilsMessageSeverityFlagsEXT messageSeverity;
- DebugUtilsMessageTypeFlagsEXT messageType;
- PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
- void* pUserData;
+ using layout::DebugUtilsMessengerCreateInfoEXT::sType;
};
static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugUtilsMessengerCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DebugUtilsObjectTagInfoEXT
+ namespace layout
{
- DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown,
- uint64_t objectHandle_ = 0,
- uint64_t tagName_ = 0,
- size_t tagSize_ = 0,
- const void* pTag_ = nullptr )
- : objectType( objectType_ )
- , objectHandle( objectHandle_ )
- , tagName( tagName_ )
- , tagSize( tagSize_ )
- , pTag( pTag_ )
+ struct DebugUtilsObjectTagInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
+ uint64_t objectHandle_ = 0,
+ uint64_t tagName_ = 0,
+ size_t tagSize_ = 0,
+ const void* pTag_ = nullptr )
+ : objectType( objectType_ )
+ , objectHandle( objectHandle_ )
+ , tagName( tagName_ )
+ , tagSize( tagSize_ )
+ , pTag( pTag_ )
+ {}
+
+ DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
+ }
+
+ DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
+ const void* pNext = nullptr;
+ vk::ObjectType objectType;
+ uint64_t objectHandle;
+ uint64_t tagName;
+ size_t tagSize;
+ const void* pTag;
+ };
+ static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DebugUtilsObjectTagInfoEXT : public layout::DebugUtilsObjectTagInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown,
+ uint64_t objectHandle_ = 0,
+ uint64_t tagName_ = 0,
+ size_t tagSize_ = 0,
+ const void* pTag_ = nullptr )
+ : layout::DebugUtilsObjectTagInfoEXT( objectType_, objectHandle_, tagName_, tagSize_, pTag_ )
{}
DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
- }
+ : layout::DebugUtilsObjectTagInfoEXT( rhs )
+ {}
DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
+ layout::DebugUtilsObjectTagInfoEXT::operator=(rhs);
return *this;
}
@@ -23904,7 +27803,7 @@
return *this;
}
- DebugUtilsObjectTagInfoEXT & setObjectType( ObjectType objectType_ )
+ DebugUtilsObjectTagInfoEXT & setObjectType( vk::ObjectType objectType_ )
{
objectType = objectType_;
return *this;
@@ -23961,32 +27860,52 @@
}
private:
- StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT;
-
- public:
- const void* pNext = nullptr;
- ObjectType objectType;
- uint64_t objectHandle;
- uint64_t tagName;
- size_t tagSize;
- const void* pTag;
+ using layout::DebugUtilsObjectTagInfoEXT::sType;
};
static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DebugUtilsObjectTagInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DedicatedAllocationBufferCreateInfoNV
+ namespace layout
{
- DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
- : dedicatedAllocation( dedicatedAllocation_ )
+ struct DedicatedAllocationBufferCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+ : dedicatedAllocation( dedicatedAllocation_ )
+ {}
+
+ DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
+ }
+
+ DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::Bool32 dedicatedAllocation;
+ };
+ static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DedicatedAllocationBufferCreateInfoNV : public layout::DedicatedAllocationBufferCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+ : layout::DedicatedAllocationBufferCreateInfoNV( dedicatedAllocation_ )
{}
DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
- }
+ : layout::DedicatedAllocationBufferCreateInfoNV( rhs )
+ {}
DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
+ layout::DedicatedAllocationBufferCreateInfoNV::operator=(rhs);
return *this;
}
@@ -23996,7 +27915,7 @@
return *this;
}
- DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ )
+ DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( vk::Bool32 dedicatedAllocation_ )
{
dedicatedAllocation = dedicatedAllocation_;
return *this;
@@ -24025,28 +27944,52 @@
}
private:
- StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- Bool32 dedicatedAllocation;
+ using layout::DedicatedAllocationBufferCreateInfoNV::sType;
};
static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DedicatedAllocationBufferCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct DedicatedAllocationImageCreateInfoNV
+ namespace layout
{
- DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
- : dedicatedAllocation( dedicatedAllocation_ )
+ struct DedicatedAllocationImageCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+ : dedicatedAllocation( dedicatedAllocation_ )
+ {}
+
+ DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
+ }
+
+ DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::Bool32 dedicatedAllocation;
+ };
+ static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DedicatedAllocationImageCreateInfoNV : public layout::DedicatedAllocationImageCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 )
+ : layout::DedicatedAllocationImageCreateInfoNV( dedicatedAllocation_ )
{}
DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
- }
+ : layout::DedicatedAllocationImageCreateInfoNV( rhs )
+ {}
DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
+ layout::DedicatedAllocationImageCreateInfoNV::operator=(rhs);
return *this;
}
@@ -24056,7 +27999,7 @@
return *this;
}
- DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ )
+ DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( vk::Bool32 dedicatedAllocation_ )
{
dedicatedAllocation = dedicatedAllocation_;
return *this;
@@ -24085,30 +28028,56 @@
}
private:
- StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- Bool32 dedicatedAllocation;
+ using layout::DedicatedAllocationImageCreateInfoNV::sType;
};
static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DedicatedAllocationImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct DedicatedAllocationMemoryAllocateInfoNV
+ namespace layout
{
- DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(),
- Buffer buffer_ = Buffer() )
- : image( image_ )
- , buffer( buffer_ )
+ struct DedicatedAllocationMemoryAllocateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(),
+ vk::Buffer buffer_ = vk::Buffer() )
+ : image( image_ )
+ , buffer( buffer_ )
+ {}
+
+ DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
+ }
+
+ DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
+ const void* pNext = nullptr;
+ vk::Image image;
+ vk::Buffer buffer;
+ };
+ static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DedicatedAllocationMemoryAllocateInfoNV : public layout::DedicatedAllocationMemoryAllocateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(),
+ vk::Buffer buffer_ = vk::Buffer() )
+ : layout::DedicatedAllocationMemoryAllocateInfoNV( image_, buffer_ )
{}
DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
- }
+ : layout::DedicatedAllocationMemoryAllocateInfoNV( rhs )
+ {}
DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
+ layout::DedicatedAllocationMemoryAllocateInfoNV::operator=(rhs);
return *this;
}
@@ -24118,13 +28087,13 @@
return *this;
}
- DedicatedAllocationMemoryAllocateInfoNV & setImage( Image image_ )
+ DedicatedAllocationMemoryAllocateInfoNV & setImage( vk::Image image_ )
{
image = image_;
return *this;
}
- DedicatedAllocationMemoryAllocateInfoNV & setBuffer( Buffer buffer_ )
+ DedicatedAllocationMemoryAllocateInfoNV & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
@@ -24154,20 +28123,16 @@
}
private:
- StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
-
- public:
- const void* pNext = nullptr;
- Image image;
- Buffer buffer;
+ using layout::DedicatedAllocationMemoryAllocateInfoNV::sType;
};
static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DedicatedAllocationMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
struct DescriptorBufferInfo
{
- DescriptorBufferInfo( Buffer buffer_ = Buffer(),
- DeviceSize offset_ = 0,
- DeviceSize range_ = 0 )
+ VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( vk::Buffer buffer_ = vk::Buffer(),
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize range_ = 0 )
: buffer( buffer_ )
, offset( offset_ )
, range( range_ )
@@ -24175,28 +28140,28 @@
DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
+ *reinterpret_cast<VkDescriptorBufferInfo*>(this) = rhs;
}
DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
+ *reinterpret_cast<VkDescriptorBufferInfo*>(this) = rhs;
return *this;
}
- DescriptorBufferInfo & setBuffer( Buffer buffer_ )
+ DescriptorBufferInfo & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- DescriptorBufferInfo & setOffset( DeviceSize offset_ )
+ DescriptorBufferInfo & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
}
- DescriptorBufferInfo & setRange( DeviceSize range_ )
+ DescriptorBufferInfo & setRange( vk::DeviceSize range_ )
{
range = range_;
return *this;
@@ -24224,17 +28189,19 @@
return !operator==( rhs );
}
- Buffer buffer;
- DeviceSize offset;
- DeviceSize range;
+ public:
+ vk::Buffer buffer;
+ vk::DeviceSize offset;
+ vk::DeviceSize range;
};
static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorBufferInfo>::value, "struct wrapper is not a standard layout!" );
struct DescriptorImageInfo
{
- DescriptorImageInfo( Sampler sampler_ = Sampler(),
- ImageView imageView_ = ImageView(),
- ImageLayout imageLayout_ = ImageLayout::eUndefined )
+ VULKAN_HPP_CONSTEXPR DescriptorImageInfo( vk::Sampler sampler_ = vk::Sampler(),
+ vk::ImageView imageView_ = vk::ImageView(),
+ vk::ImageLayout imageLayout_ = vk::ImageLayout::eUndefined )
: sampler( sampler_ )
, imageView( imageView_ )
, imageLayout( imageLayout_ )
@@ -24242,28 +28209,28 @@
DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
+ *reinterpret_cast<VkDescriptorImageInfo*>(this) = rhs;
}
DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
+ *reinterpret_cast<VkDescriptorImageInfo*>(this) = rhs;
return *this;
}
- DescriptorImageInfo & setSampler( Sampler sampler_ )
+ DescriptorImageInfo & setSampler( vk::Sampler sampler_ )
{
sampler = sampler_;
return *this;
}
- DescriptorImageInfo & setImageView( ImageView imageView_ )
+ DescriptorImageInfo & setImageView( vk::ImageView imageView_ )
{
imageView = imageView_;
return *this;
}
- DescriptorImageInfo & setImageLayout( ImageLayout imageLayout_ )
+ DescriptorImageInfo & setImageLayout( vk::ImageLayout imageLayout_ )
{
imageLayout = imageLayout_;
return *this;
@@ -24291,32 +28258,34 @@
return !operator==( rhs );
}
- Sampler sampler;
- ImageView imageView;
- ImageLayout imageLayout;
+ public:
+ vk::Sampler sampler;
+ vk::ImageView imageView;
+ vk::ImageLayout imageLayout;
};
static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorImageInfo>::value, "struct wrapper is not a standard layout!" );
struct DescriptorPoolSize
{
- DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler,
- uint32_t descriptorCount_ = 0 )
+ VULKAN_HPP_CONSTEXPR DescriptorPoolSize( vk::DescriptorType type_ = vk::DescriptorType::eSampler,
+ uint32_t descriptorCount_ = 0 )
: type( type_ )
, descriptorCount( descriptorCount_ )
{}
DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
+ *reinterpret_cast<VkDescriptorPoolSize*>(this) = rhs;
}
DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
+ *reinterpret_cast<VkDescriptorPoolSize*>(this) = rhs;
return *this;
}
- DescriptorPoolSize & setType( DescriptorType type_ )
+ DescriptorPoolSize & setType( vk::DescriptorType type_ )
{
type = type_;
return *this;
@@ -24349,31 +28318,66 @@
return !operator==( rhs );
}
- DescriptorType type;
+ public:
+ vk::DescriptorType type;
uint32_t descriptorCount;
};
static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorPoolSize>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorPoolCreateInfo
+ namespace layout
{
- DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(),
- uint32_t maxSets_ = 0,
- uint32_t poolSizeCount_ = 0,
- const DescriptorPoolSize* pPoolSizes_ = nullptr )
- : flags( flags_ )
- , maxSets( maxSets_ )
- , poolSizeCount( poolSizeCount_ )
- , pPoolSizes( pPoolSizes_ )
+ struct DescriptorPoolCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(),
+ uint32_t maxSets_ = 0,
+ uint32_t poolSizeCount_ = 0,
+ const vk::DescriptorPoolSize* pPoolSizes_ = nullptr )
+ : flags( flags_ )
+ , maxSets( maxSets_ )
+ , poolSizeCount( poolSizeCount_ )
+ , pPoolSizes( pPoolSizes_ )
+ {}
+
+ DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this) = rhs;
+ }
+
+ DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorPoolCreateInfo;
+ const void* pNext = nullptr;
+ vk::DescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+ uint32_t poolSizeCount;
+ const vk::DescriptorPoolSize* pPoolSizes;
+ };
+ static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorPoolCreateInfo : public layout::DescriptorPoolCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(),
+ uint32_t maxSets_ = 0,
+ uint32_t poolSizeCount_ = 0,
+ const vk::DescriptorPoolSize* pPoolSizes_ = nullptr )
+ : layout::DescriptorPoolCreateInfo( flags_, maxSets_, poolSizeCount_, pPoolSizes_ )
{}
DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
- }
+ : layout::DescriptorPoolCreateInfo( rhs )
+ {}
DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
+ layout::DescriptorPoolCreateInfo::operator=(rhs);
return *this;
}
@@ -24383,7 +28387,7 @@
return *this;
}
- DescriptorPoolCreateInfo & setFlags( DescriptorPoolCreateFlags flags_ )
+ DescriptorPoolCreateInfo & setFlags( vk::DescriptorPoolCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -24401,7 +28405,7 @@
return *this;
}
- DescriptorPoolCreateInfo & setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
+ DescriptorPoolCreateInfo & setPPoolSizes( const vk::DescriptorPoolSize* pPoolSizes_ )
{
pPoolSizes = pPoolSizes_;
return *this;
@@ -24433,31 +28437,52 @@
}
private:
- StructureType sType = StructureType::eDescriptorPoolCreateInfo;
-
- public:
- const void* pNext = nullptr;
- DescriptorPoolCreateFlags flags;
- uint32_t maxSets;
- uint32_t poolSizeCount;
- const DescriptorPoolSize* pPoolSizes;
+ using layout::DescriptorPoolCreateInfo::sType;
};
static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorPoolInlineUniformBlockCreateInfoEXT
+ namespace layout
{
- DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
- : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
+ struct DescriptorPoolInlineUniformBlockCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
+ : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
+ {}
+
+ DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
+ }
+
+ DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
+ const void* pNext = nullptr;
+ uint32_t maxInlineUniformBlockBindings;
+ };
+ static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorPoolInlineUniformBlockCreateInfoEXT : public layout::DescriptorPoolInlineUniformBlockCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
+ : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( maxInlineUniformBlockBindings_ )
{}
DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
- }
+ : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( rhs )
+ {}
DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) );
+ layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -24496,32 +28521,60 @@
}
private:
- StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t maxInlineUniformBlockBindings;
+ using layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::sType;
};
static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorPoolInlineUniformBlockCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorSetAllocateInfo
+ namespace layout
{
- DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(),
- uint32_t descriptorSetCount_ = 0,
- const DescriptorSetLayout* pSetLayouts_ = nullptr )
- : descriptorPool( descriptorPool_ )
- , descriptorSetCount( descriptorSetCount_ )
- , pSetLayouts( pSetLayouts_ )
+ struct DescriptorSetAllocateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(),
+ uint32_t descriptorSetCount_ = 0,
+ const vk::DescriptorSetLayout* pSetLayouts_ = nullptr )
+ : descriptorPool( descriptorPool_ )
+ , descriptorSetCount( descriptorSetCount_ )
+ , pSetLayouts( pSetLayouts_ )
+ {}
+
+ DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this) = rhs;
+ }
+
+ DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorSetAllocateInfo;
+ const void* pNext = nullptr;
+ vk::DescriptorPool descriptorPool;
+ uint32_t descriptorSetCount;
+ const vk::DescriptorSetLayout* pSetLayouts;
+ };
+ static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorSetAllocateInfo : public layout::DescriptorSetAllocateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(),
+ uint32_t descriptorSetCount_ = 0,
+ const vk::DescriptorSetLayout* pSetLayouts_ = nullptr )
+ : layout::DescriptorSetAllocateInfo( descriptorPool_, descriptorSetCount_, pSetLayouts_ )
{}
DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
- }
+ : layout::DescriptorSetAllocateInfo( rhs )
+ {}
DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
+ layout::DescriptorSetAllocateInfo::operator=(rhs);
return *this;
}
@@ -24531,7 +28584,7 @@
return *this;
}
- DescriptorSetAllocateInfo & setDescriptorPool( DescriptorPool descriptorPool_ )
+ DescriptorSetAllocateInfo & setDescriptorPool( vk::DescriptorPool descriptorPool_ )
{
descriptorPool = descriptorPool_;
return *this;
@@ -24543,7 +28596,7 @@
return *this;
}
- DescriptorSetAllocateInfo & setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+ DescriptorSetAllocateInfo & setPSetLayouts( const vk::DescriptorSetLayout* pSetLayouts_ )
{
pSetLayouts = pSetLayouts_;
return *this;
@@ -24574,23 +28627,18 @@
}
private:
- StructureType sType = StructureType::eDescriptorSetAllocateInfo;
-
- public:
- const void* pNext = nullptr;
- DescriptorPool descriptorPool;
- uint32_t descriptorSetCount;
- const DescriptorSetLayout* pSetLayouts;
+ using layout::DescriptorSetAllocateInfo::sType;
};
static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetAllocateInfo>::value, "struct wrapper is not a standard layout!" );
struct DescriptorSetLayoutBinding
{
- DescriptorSetLayoutBinding( uint32_t binding_ = 0,
- DescriptorType descriptorType_ = DescriptorType::eSampler,
- uint32_t descriptorCount_ = 0,
- ShaderStageFlags stageFlags_ = ShaderStageFlags(),
- const Sampler* pImmutableSamplers_ = nullptr )
+ VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t binding_ = 0,
+ vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+ uint32_t descriptorCount_ = 0,
+ vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags(),
+ const vk::Sampler* pImmutableSamplers_ = nullptr )
: binding( binding_ )
, descriptorType( descriptorType_ )
, descriptorCount( descriptorCount_ )
@@ -24600,12 +28648,12 @@
DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
+ *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this) = rhs;
}
DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
+ *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this) = rhs;
return *this;
}
@@ -24615,7 +28663,7 @@
return *this;
}
- DescriptorSetLayoutBinding & setDescriptorType( DescriptorType descriptorType_ )
+ DescriptorSetLayoutBinding & setDescriptorType( vk::DescriptorType descriptorType_ )
{
descriptorType = descriptorType_;
return *this;
@@ -24627,13 +28675,13 @@
return *this;
}
- DescriptorSetLayoutBinding & setStageFlags( ShaderStageFlags stageFlags_ )
+ DescriptorSetLayoutBinding & setStageFlags( vk::ShaderStageFlags stageFlags_ )
{
stageFlags = stageFlags_;
return *this;
}
- DescriptorSetLayoutBinding & setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
+ DescriptorSetLayoutBinding & setPImmutableSamplers( const vk::Sampler* pImmutableSamplers_ )
{
pImmutableSamplers = pImmutableSamplers_;
return *this;
@@ -24663,30 +28711,61 @@
return !operator==( rhs );
}
+ public:
uint32_t binding;
- DescriptorType descriptorType;
+ vk::DescriptorType descriptorType;
uint32_t descriptorCount;
- ShaderStageFlags stageFlags;
- const Sampler* pImmutableSamplers;
+ vk::ShaderStageFlags stageFlags;
+ const vk::Sampler* pImmutableSamplers;
};
static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetLayoutBinding>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
+ namespace layout
{
- DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
- const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
- : bindingCount( bindingCount_ )
- , pBindingFlags( pBindingFlags_ )
+ struct DescriptorSetLayoutBindingFlagsCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
+ const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
+ : bindingCount( bindingCount_ )
+ , pBindingFlags( pBindingFlags_ )
+ {}
+
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
+ }
+
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+ const void* pNext = nullptr;
+ uint32_t bindingCount;
+ const vk::DescriptorBindingFlagsEXT* pBindingFlags;
+ };
+ static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorSetLayoutBindingFlagsCreateInfoEXT : public layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0,
+ const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
+ : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( bindingCount_, pBindingFlags_ )
{}
DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
- }
+ : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( rhs )
+ {}
DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) );
+ layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -24702,7 +28781,7 @@
return *this;
}
- DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags( const DescriptorBindingFlagsEXT* pBindingFlags_ )
+ DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags( const vk::DescriptorBindingFlagsEXT* pBindingFlags_ )
{
pBindingFlags = pBindingFlags_;
return *this;
@@ -24732,33 +28811,60 @@
}
private:
- StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t bindingCount;
- const DescriptorBindingFlagsEXT* pBindingFlags;
+ using layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::sType;
};
static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetLayoutBindingFlagsCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorSetLayoutCreateInfo
+ namespace layout
{
- DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(),
- uint32_t bindingCount_ = 0,
- const DescriptorSetLayoutBinding* pBindings_ = nullptr )
- : flags( flags_ )
- , bindingCount( bindingCount_ )
- , pBindings( pBindings_ )
+ struct DescriptorSetLayoutCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(),
+ uint32_t bindingCount_ = 0,
+ const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr )
+ : flags( flags_ )
+ , bindingCount( bindingCount_ )
+ , pBindings( pBindings_ )
+ {}
+
+ DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
+ }
+
+ DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
+ const void* pNext = nullptr;
+ vk::DescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+ const vk::DescriptorSetLayoutBinding* pBindings;
+ };
+ static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorSetLayoutCreateInfo : public layout::DescriptorSetLayoutCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(),
+ uint32_t bindingCount_ = 0,
+ const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr )
+ : layout::DescriptorSetLayoutCreateInfo( flags_, bindingCount_, pBindings_ )
{}
DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
- }
+ : layout::DescriptorSetLayoutCreateInfo( rhs )
+ {}
DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
+ layout::DescriptorSetLayoutCreateInfo::operator=(rhs);
return *this;
}
@@ -24768,7 +28874,7 @@
return *this;
}
- DescriptorSetLayoutCreateInfo & setFlags( DescriptorSetLayoutCreateFlags flags_ )
+ DescriptorSetLayoutCreateInfo & setFlags( vk::DescriptorSetLayoutCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -24780,7 +28886,7 @@
return *this;
}
- DescriptorSetLayoutCreateInfo & setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
+ DescriptorSetLayoutCreateInfo & setPBindings( const vk::DescriptorSetLayoutBinding* pBindings_ )
{
pBindings = pBindings_;
return *this;
@@ -24811,18 +28917,54 @@
}
private:
- StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
-
- public:
- const void* pNext = nullptr;
- DescriptorSetLayoutCreateFlags flags;
- uint32_t bindingCount;
- const DescriptorSetLayoutBinding* pBindings;
+ using layout::DescriptorSetLayoutCreateInfo::sType;
};
static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorSetLayoutSupport
+ namespace layout
{
+ struct DescriptorSetLayoutSupport
+ {
+ protected:
+ DescriptorSetLayoutSupport()
+ {}
+
+ DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this) = rhs;
+ }
+
+ DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport;
+ void* pNext = nullptr;
+ vk::Bool32 supported;
+ };
+ static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorSetLayoutSupport : public layout::DescriptorSetLayoutSupport
+ {
+ DescriptorSetLayoutSupport()
+ : layout::DescriptorSetLayoutSupport()
+ {}
+
+ DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs )
+ : layout::DescriptorSetLayoutSupport( rhs )
+ {}
+
+ DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs )
+ {
+ layout::DescriptorSetLayoutSupport::operator=(rhs);
+ return *this;
+ }
+
operator VkDescriptorSetLayoutSupport const&() const
{
return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>( this );
@@ -24846,30 +28988,56 @@
}
private:
- StructureType sType = StructureType::eDescriptorSetLayoutSupport;
-
- public:
- void* pNext = nullptr;
- Bool32 supported;
+ using layout::DescriptorSetLayoutSupport::sType;
};
static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetLayoutSupport>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
+ namespace layout
{
- DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
- const uint32_t* pDescriptorCounts_ = nullptr )
- : descriptorSetCount( descriptorSetCount_ )
- , pDescriptorCounts( pDescriptorCounts_ )
+ struct DescriptorSetVariableDescriptorCountAllocateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
+ const uint32_t* pDescriptorCounts_ = nullptr )
+ : descriptorSetCount( descriptorSetCount_ )
+ , pDescriptorCounts( pDescriptorCounts_ )
+ {}
+
+ DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
+ }
+
+ DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
+ const void* pNext = nullptr;
+ uint32_t descriptorSetCount;
+ const uint32_t* pDescriptorCounts;
+ };
+ static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorSetVariableDescriptorCountAllocateInfoEXT : public layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0,
+ const uint32_t* pDescriptorCounts_ = nullptr )
+ : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( descriptorSetCount_, pDescriptorCounts_ )
{}
DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) );
- }
+ : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( rhs )
+ {}
DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) );
+ layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::operator=(rhs);
return *this;
}
@@ -24915,17 +29083,54 @@
}
private:
- StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t descriptorSetCount;
- const uint32_t* pDescriptorCounts;
+ using layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::sType;
};
static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
+ namespace layout
{
+ struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
+ {
+ protected:
+ DescriptorSetVariableDescriptorCountLayoutSupportEXT()
+ {}
+
+ DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this) = rhs;
+ }
+
+ DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+ void* pNext = nullptr;
+ uint32_t maxVariableDescriptorCount;
+ };
+ static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorSetVariableDescriptorCountLayoutSupportEXT : public layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT
+ {
+ DescriptorSetVariableDescriptorCountLayoutSupportEXT()
+ : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT()
+ {}
+
+ DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs )
+ : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT( rhs )
+ {}
+
+ DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs )
+ {
+ layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const&() const
{
return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>( this );
@@ -24949,22 +29154,19 @@
}
private:
- StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t maxVariableDescriptorCount;
+ using layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::sType;
};
static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountLayoutSupportEXT>::value, "struct wrapper is not a standard layout!" );
struct DescriptorUpdateTemplateEntry
{
- DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0,
- uint32_t dstArrayElement_ = 0,
- uint32_t descriptorCount_ = 0,
- DescriptorType descriptorType_ = DescriptorType::eSampler,
- size_t offset_ = 0,
- size_t stride_ = 0 )
+ VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = 0,
+ uint32_t dstArrayElement_ = 0,
+ uint32_t descriptorCount_ = 0,
+ vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+ size_t offset_ = 0,
+ size_t stride_ = 0 )
: dstBinding( dstBinding_ )
, dstArrayElement( dstArrayElement_ )
, descriptorCount( descriptorCount_ )
@@ -24975,12 +29177,12 @@
DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
+ *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this) = rhs;
}
DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
+ *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this) = rhs;
return *this;
}
@@ -25002,7 +29204,7 @@
return *this;
}
- DescriptorUpdateTemplateEntry & setDescriptorType( DescriptorType descriptorType_ )
+ DescriptorUpdateTemplateEntry & setDescriptorType( vk::DescriptorType descriptorType_ )
{
descriptorType = descriptorType_;
return *this;
@@ -25045,43 +29247,86 @@
return !operator==( rhs );
}
+ public:
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
- DescriptorType descriptorType;
+ vk::DescriptorType descriptorType;
size_t offset;
size_t stride;
};
static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorUpdateTemplateEntry>::value, "struct wrapper is not a standard layout!" );
- struct DescriptorUpdateTemplateCreateInfo
+ namespace layout
{
- DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = DescriptorUpdateTemplateCreateFlags(),
- uint32_t descriptorUpdateEntryCount_ = 0,
- const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
- DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet,
- DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
- PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- uint32_t set_ = 0 )
- : flags( flags_ )
- , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
- , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
- , templateType( templateType_ )
- , descriptorSetLayout( descriptorSetLayout_ )
- , pipelineBindPoint( pipelineBindPoint_ )
- , pipelineLayout( pipelineLayout_ )
- , set( set_ )
+ struct DescriptorUpdateTemplateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(),
+ uint32_t descriptorUpdateEntryCount_ = 0,
+ const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+ vk::DescriptorUpdateTemplateType templateType_ = vk::DescriptorUpdateTemplateType::eDescriptorSet,
+ vk::DescriptorSetLayout descriptorSetLayout_ = vk::DescriptorSetLayout(),
+ vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+ uint32_t set_ = 0 )
+ : flags( flags_ )
+ , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
+ , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
+ , templateType( templateType_ )
+ , descriptorSetLayout( descriptorSetLayout_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , pipelineLayout( pipelineLayout_ )
+ , set( set_ )
+ {}
+
+ DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
+ }
+
+ DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
+ const void* pNext = nullptr;
+ vk::DescriptorUpdateTemplateCreateFlags flags;
+ uint32_t descriptorUpdateEntryCount;
+ const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
+ vk::DescriptorUpdateTemplateType templateType;
+ vk::DescriptorSetLayout descriptorSetLayout;
+ vk::PipelineBindPoint pipelineBindPoint;
+ vk::PipelineLayout pipelineLayout;
+ uint32_t set;
+ };
+ static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DescriptorUpdateTemplateCreateInfo : public layout::DescriptorUpdateTemplateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(),
+ uint32_t descriptorUpdateEntryCount_ = 0,
+ const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
+ vk::DescriptorUpdateTemplateType templateType_ = vk::DescriptorUpdateTemplateType::eDescriptorSet,
+ vk::DescriptorSetLayout descriptorSetLayout_ = vk::DescriptorSetLayout(),
+ vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+ uint32_t set_ = 0 )
+ : layout::DescriptorUpdateTemplateCreateInfo( flags_, descriptorUpdateEntryCount_, pDescriptorUpdateEntries_, templateType_, descriptorSetLayout_, pipelineBindPoint_, pipelineLayout_, set_ )
{}
DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
- }
+ : layout::DescriptorUpdateTemplateCreateInfo( rhs )
+ {}
DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
+ layout::DescriptorUpdateTemplateCreateInfo::operator=(rhs);
return *this;
}
@@ -25091,7 +29336,7 @@
return *this;
}
- DescriptorUpdateTemplateCreateInfo & setFlags( DescriptorUpdateTemplateCreateFlags flags_ )
+ DescriptorUpdateTemplateCreateInfo & setFlags( vk::DescriptorUpdateTemplateCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -25103,31 +29348,31 @@
return *this;
}
- DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
+ DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries( const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ )
{
pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo & setTemplateType( DescriptorUpdateTemplateType templateType_ )
+ DescriptorUpdateTemplateCreateInfo & setTemplateType( vk::DescriptorUpdateTemplateType templateType_ )
{
templateType = templateType_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
+ DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout_ )
{
descriptorSetLayout = descriptorSetLayout_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
{
pipelineBindPoint = pipelineBindPoint_;
return *this;
}
- DescriptorUpdateTemplateCreateInfo & setPipelineLayout( PipelineLayout pipelineLayout_ )
+ DescriptorUpdateTemplateCreateInfo & setPipelineLayout( vk::PipelineLayout pipelineLayout_ )
{
pipelineLayout = pipelineLayout_;
return *this;
@@ -25169,41 +29414,64 @@
}
private:
- StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- DescriptorUpdateTemplateCreateFlags flags;
- uint32_t descriptorUpdateEntryCount;
- const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
- DescriptorUpdateTemplateType templateType;
- DescriptorSetLayout descriptorSetLayout;
- PipelineBindPoint pipelineBindPoint;
- PipelineLayout pipelineLayout;
- uint32_t set;
+ using layout::DescriptorUpdateTemplateCreateInfo::sType;
};
static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DescriptorUpdateTemplateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceQueueCreateInfo
+ namespace layout
{
- DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
- uint32_t queueFamilyIndex_ = 0,
- uint32_t queueCount_ = 0,
- const float* pQueuePriorities_ = nullptr )
- : flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
- , queueCount( queueCount_ )
- , pQueuePriorities( pQueuePriorities_ )
+ struct DeviceQueueCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0,
+ uint32_t queueCount_ = 0,
+ const float* pQueuePriorities_ = nullptr )
+ : flags( flags_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ , queueCount( queueCount_ )
+ , pQueuePriorities( pQueuePriorities_ )
+ {}
+
+ DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceQueueCreateInfo*>(this) = rhs;
+ }
+
+ DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceQueueCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceQueueCreateInfo;
+ const void* pNext = nullptr;
+ vk::DeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queueCount;
+ const float* pQueuePriorities;
+ };
+ static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceQueueCreateInfo : public layout::DeviceQueueCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0,
+ uint32_t queueCount_ = 0,
+ const float* pQueuePriorities_ = nullptr )
+ : layout::DeviceQueueCreateInfo( flags_, queueFamilyIndex_, queueCount_, pQueuePriorities_ )
{}
DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
- }
+ : layout::DeviceQueueCreateInfo( rhs )
+ {}
DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
+ layout::DeviceQueueCreateInfo::operator=(rhs);
return *this;
}
@@ -25213,7 +29481,7 @@
return *this;
}
- DeviceQueueCreateInfo & setFlags( DeviceQueueCreateFlags flags_ )
+ DeviceQueueCreateInfo & setFlags( vk::DeviceQueueCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -25263,74 +29531,68 @@
}
private:
- StructureType sType = StructureType::eDeviceQueueCreateInfo;
-
- public:
- const void* pNext = nullptr;
- DeviceQueueCreateFlags flags;
- uint32_t queueFamilyIndex;
- uint32_t queueCount;
- const float* pQueuePriorities;
+ using layout::DeviceQueueCreateInfo::sType;
};
static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceQueueCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct PhysicalDeviceFeatures
{
- 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 )
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( vk::Bool32 robustBufferAccess_ = 0,
+ vk::Bool32 fullDrawIndexUint32_ = 0,
+ vk::Bool32 imageCubeArray_ = 0,
+ vk::Bool32 independentBlend_ = 0,
+ vk::Bool32 geometryShader_ = 0,
+ vk::Bool32 tessellationShader_ = 0,
+ vk::Bool32 sampleRateShading_ = 0,
+ vk::Bool32 dualSrcBlend_ = 0,
+ vk::Bool32 logicOp_ = 0,
+ vk::Bool32 multiDrawIndirect_ = 0,
+ vk::Bool32 drawIndirectFirstInstance_ = 0,
+ vk::Bool32 depthClamp_ = 0,
+ vk::Bool32 depthBiasClamp_ = 0,
+ vk::Bool32 fillModeNonSolid_ = 0,
+ vk::Bool32 depthBounds_ = 0,
+ vk::Bool32 wideLines_ = 0,
+ vk::Bool32 largePoints_ = 0,
+ vk::Bool32 alphaToOne_ = 0,
+ vk::Bool32 multiViewport_ = 0,
+ vk::Bool32 samplerAnisotropy_ = 0,
+ vk::Bool32 textureCompressionETC2_ = 0,
+ vk::Bool32 textureCompressionASTC_LDR_ = 0,
+ vk::Bool32 textureCompressionBC_ = 0,
+ vk::Bool32 occlusionQueryPrecise_ = 0,
+ vk::Bool32 pipelineStatisticsQuery_ = 0,
+ vk::Bool32 vertexPipelineStoresAndAtomics_ = 0,
+ vk::Bool32 fragmentStoresAndAtomics_ = 0,
+ vk::Bool32 shaderTessellationAndGeometryPointSize_ = 0,
+ vk::Bool32 shaderImageGatherExtended_ = 0,
+ vk::Bool32 shaderStorageImageExtendedFormats_ = 0,
+ vk::Bool32 shaderStorageImageMultisample_ = 0,
+ vk::Bool32 shaderStorageImageReadWithoutFormat_ = 0,
+ vk::Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
+ vk::Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderClipDistance_ = 0,
+ vk::Bool32 shaderCullDistance_ = 0,
+ vk::Bool32 shaderFloat64_ = 0,
+ vk::Bool32 shaderInt64_ = 0,
+ vk::Bool32 shaderInt16_ = 0,
+ vk::Bool32 shaderResourceResidency_ = 0,
+ vk::Bool32 shaderResourceMinLod_ = 0,
+ vk::Bool32 sparseBinding_ = 0,
+ vk::Bool32 sparseResidencyBuffer_ = 0,
+ vk::Bool32 sparseResidencyImage2D_ = 0,
+ vk::Bool32 sparseResidencyImage3D_ = 0,
+ vk::Bool32 sparseResidency2Samples_ = 0,
+ vk::Bool32 sparseResidency4Samples_ = 0,
+ vk::Bool32 sparseResidency8Samples_ = 0,
+ vk::Bool32 sparseResidency16Samples_ = 0,
+ vk::Bool32 sparseResidencyAliased_ = 0,
+ vk::Bool32 variableMultisampleRate_ = 0,
+ vk::Bool32 inheritedQueries_ = 0 )
: robustBufferAccess( robustBufferAccess_ )
, fullDrawIndexUint32( fullDrawIndexUint32_ )
, imageCubeArray( imageCubeArray_ )
@@ -25390,340 +29652,340 @@
PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
+ *reinterpret_cast<VkPhysicalDeviceFeatures*>(this) = rhs;
}
PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
+ *reinterpret_cast<VkPhysicalDeviceFeatures*>(this) = rhs;
return *this;
}
- PhysicalDeviceFeatures & setRobustBufferAccess( Bool32 robustBufferAccess_ )
+ PhysicalDeviceFeatures & setRobustBufferAccess( vk::Bool32 robustBufferAccess_ )
{
robustBufferAccess = robustBufferAccess_;
return *this;
}
- PhysicalDeviceFeatures & setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
+ PhysicalDeviceFeatures & setFullDrawIndexUint32( vk::Bool32 fullDrawIndexUint32_ )
{
fullDrawIndexUint32 = fullDrawIndexUint32_;
return *this;
}
- PhysicalDeviceFeatures & setImageCubeArray( Bool32 imageCubeArray_ )
+ PhysicalDeviceFeatures & setImageCubeArray( vk::Bool32 imageCubeArray_ )
{
imageCubeArray = imageCubeArray_;
return *this;
}
- PhysicalDeviceFeatures & setIndependentBlend( Bool32 independentBlend_ )
+ PhysicalDeviceFeatures & setIndependentBlend( vk::Bool32 independentBlend_ )
{
independentBlend = independentBlend_;
return *this;
}
- PhysicalDeviceFeatures & setGeometryShader( Bool32 geometryShader_ )
+ PhysicalDeviceFeatures & setGeometryShader( vk::Bool32 geometryShader_ )
{
geometryShader = geometryShader_;
return *this;
}
- PhysicalDeviceFeatures & setTessellationShader( Bool32 tessellationShader_ )
+ PhysicalDeviceFeatures & setTessellationShader( vk::Bool32 tessellationShader_ )
{
tessellationShader = tessellationShader_;
return *this;
}
- PhysicalDeviceFeatures & setSampleRateShading( Bool32 sampleRateShading_ )
+ PhysicalDeviceFeatures & setSampleRateShading( vk::Bool32 sampleRateShading_ )
{
sampleRateShading = sampleRateShading_;
return *this;
}
- PhysicalDeviceFeatures & setDualSrcBlend( Bool32 dualSrcBlend_ )
+ PhysicalDeviceFeatures & setDualSrcBlend( vk::Bool32 dualSrcBlend_ )
{
dualSrcBlend = dualSrcBlend_;
return *this;
}
- PhysicalDeviceFeatures & setLogicOp( Bool32 logicOp_ )
+ PhysicalDeviceFeatures & setLogicOp( vk::Bool32 logicOp_ )
{
logicOp = logicOp_;
return *this;
}
- PhysicalDeviceFeatures & setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
+ PhysicalDeviceFeatures & setMultiDrawIndirect( vk::Bool32 multiDrawIndirect_ )
{
multiDrawIndirect = multiDrawIndirect_;
return *this;
}
- PhysicalDeviceFeatures & setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
+ PhysicalDeviceFeatures & setDrawIndirectFirstInstance( vk::Bool32 drawIndirectFirstInstance_ )
{
drawIndirectFirstInstance = drawIndirectFirstInstance_;
return *this;
}
- PhysicalDeviceFeatures & setDepthClamp( Bool32 depthClamp_ )
+ PhysicalDeviceFeatures & setDepthClamp( vk::Bool32 depthClamp_ )
{
depthClamp = depthClamp_;
return *this;
}
- PhysicalDeviceFeatures & setDepthBiasClamp( Bool32 depthBiasClamp_ )
+ PhysicalDeviceFeatures & setDepthBiasClamp( vk::Bool32 depthBiasClamp_ )
{
depthBiasClamp = depthBiasClamp_;
return *this;
}
- PhysicalDeviceFeatures & setFillModeNonSolid( Bool32 fillModeNonSolid_ )
+ PhysicalDeviceFeatures & setFillModeNonSolid( vk::Bool32 fillModeNonSolid_ )
{
fillModeNonSolid = fillModeNonSolid_;
return *this;
}
- PhysicalDeviceFeatures & setDepthBounds( Bool32 depthBounds_ )
+ PhysicalDeviceFeatures & setDepthBounds( vk::Bool32 depthBounds_ )
{
depthBounds = depthBounds_;
return *this;
}
- PhysicalDeviceFeatures & setWideLines( Bool32 wideLines_ )
+ PhysicalDeviceFeatures & setWideLines( vk::Bool32 wideLines_ )
{
wideLines = wideLines_;
return *this;
}
- PhysicalDeviceFeatures & setLargePoints( Bool32 largePoints_ )
+ PhysicalDeviceFeatures & setLargePoints( vk::Bool32 largePoints_ )
{
largePoints = largePoints_;
return *this;
}
- PhysicalDeviceFeatures & setAlphaToOne( Bool32 alphaToOne_ )
+ PhysicalDeviceFeatures & setAlphaToOne( vk::Bool32 alphaToOne_ )
{
alphaToOne = alphaToOne_;
return *this;
}
- PhysicalDeviceFeatures & setMultiViewport( Bool32 multiViewport_ )
+ PhysicalDeviceFeatures & setMultiViewport( vk::Bool32 multiViewport_ )
{
multiViewport = multiViewport_;
return *this;
}
- PhysicalDeviceFeatures & setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
+ PhysicalDeviceFeatures & setSamplerAnisotropy( vk::Bool32 samplerAnisotropy_ )
{
samplerAnisotropy = samplerAnisotropy_;
return *this;
}
- PhysicalDeviceFeatures & setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
+ PhysicalDeviceFeatures & setTextureCompressionETC2( vk::Bool32 textureCompressionETC2_ )
{
textureCompressionETC2 = textureCompressionETC2_;
return *this;
}
- PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
+ PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( vk::Bool32 textureCompressionASTC_LDR_ )
{
textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
return *this;
}
- PhysicalDeviceFeatures & setTextureCompressionBC( Bool32 textureCompressionBC_ )
+ PhysicalDeviceFeatures & setTextureCompressionBC( vk::Bool32 textureCompressionBC_ )
{
textureCompressionBC = textureCompressionBC_;
return *this;
}
- PhysicalDeviceFeatures & setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
+ PhysicalDeviceFeatures & setOcclusionQueryPrecise( vk::Bool32 occlusionQueryPrecise_ )
{
occlusionQueryPrecise = occlusionQueryPrecise_;
return *this;
}
- PhysicalDeviceFeatures & setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
+ PhysicalDeviceFeatures & setPipelineStatisticsQuery( vk::Bool32 pipelineStatisticsQuery_ )
{
pipelineStatisticsQuery = pipelineStatisticsQuery_;
return *this;
}
- PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
+ PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( vk::Bool32 vertexPipelineStoresAndAtomics_ )
{
vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
return *this;
}
- PhysicalDeviceFeatures & setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
+ PhysicalDeviceFeatures & setFragmentStoresAndAtomics( vk::Bool32 fragmentStoresAndAtomics_ )
{
fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
return *this;
}
- PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
+ PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( vk::Bool32 shaderTessellationAndGeometryPointSize_ )
{
shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
return *this;
}
- PhysicalDeviceFeatures & setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
+ PhysicalDeviceFeatures & setShaderImageGatherExtended( vk::Bool32 shaderImageGatherExtended_ )
{
shaderImageGatherExtended = shaderImageGatherExtended_;
return *this;
}
- PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
+ PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( vk::Bool32 shaderStorageImageExtendedFormats_ )
{
shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
return *this;
}
- PhysicalDeviceFeatures & setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
+ PhysicalDeviceFeatures & setShaderStorageImageMultisample( vk::Bool32 shaderStorageImageMultisample_ )
{
shaderStorageImageMultisample = shaderStorageImageMultisample_;
return *this;
}
- PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
+ PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( vk::Bool32 shaderStorageImageReadWithoutFormat_ )
{
shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
return *this;
}
- PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
+ PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( vk::Bool32 shaderStorageImageWriteWithoutFormat_ )
{
shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
return *this;
}
- PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
+ PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( vk::Bool32 shaderUniformBufferArrayDynamicIndexing_ )
{
shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
+ PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( vk::Bool32 shaderSampledImageArrayDynamicIndexing_ )
{
shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
+ PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( vk::Bool32 shaderStorageBufferArrayDynamicIndexing_ )
{
shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
+ PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( vk::Bool32 shaderStorageImageArrayDynamicIndexing_ )
{
shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceFeatures & setShaderClipDistance( Bool32 shaderClipDistance_ )
+ PhysicalDeviceFeatures & setShaderClipDistance( vk::Bool32 shaderClipDistance_ )
{
shaderClipDistance = shaderClipDistance_;
return *this;
}
- PhysicalDeviceFeatures & setShaderCullDistance( Bool32 shaderCullDistance_ )
+ PhysicalDeviceFeatures & setShaderCullDistance( vk::Bool32 shaderCullDistance_ )
{
shaderCullDistance = shaderCullDistance_;
return *this;
}
- PhysicalDeviceFeatures & setShaderFloat64( Bool32 shaderFloat64_ )
+ PhysicalDeviceFeatures & setShaderFloat64( vk::Bool32 shaderFloat64_ )
{
shaderFloat64 = shaderFloat64_;
return *this;
}
- PhysicalDeviceFeatures & setShaderInt64( Bool32 shaderInt64_ )
+ PhysicalDeviceFeatures & setShaderInt64( vk::Bool32 shaderInt64_ )
{
shaderInt64 = shaderInt64_;
return *this;
}
- PhysicalDeviceFeatures & setShaderInt16( Bool32 shaderInt16_ )
+ PhysicalDeviceFeatures & setShaderInt16( vk::Bool32 shaderInt16_ )
{
shaderInt16 = shaderInt16_;
return *this;
}
- PhysicalDeviceFeatures & setShaderResourceResidency( Bool32 shaderResourceResidency_ )
+ PhysicalDeviceFeatures & setShaderResourceResidency( vk::Bool32 shaderResourceResidency_ )
{
shaderResourceResidency = shaderResourceResidency_;
return *this;
}
- PhysicalDeviceFeatures & setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
+ PhysicalDeviceFeatures & setShaderResourceMinLod( vk::Bool32 shaderResourceMinLod_ )
{
shaderResourceMinLod = shaderResourceMinLod_;
return *this;
}
- PhysicalDeviceFeatures & setSparseBinding( Bool32 sparseBinding_ )
+ PhysicalDeviceFeatures & setSparseBinding( vk::Bool32 sparseBinding_ )
{
sparseBinding = sparseBinding_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
+ PhysicalDeviceFeatures & setSparseResidencyBuffer( vk::Bool32 sparseResidencyBuffer_ )
{
sparseResidencyBuffer = sparseResidencyBuffer_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
+ PhysicalDeviceFeatures & setSparseResidencyImage2D( vk::Bool32 sparseResidencyImage2D_ )
{
sparseResidencyImage2D = sparseResidencyImage2D_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
+ PhysicalDeviceFeatures & setSparseResidencyImage3D( vk::Bool32 sparseResidencyImage3D_ )
{
sparseResidencyImage3D = sparseResidencyImage3D_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
+ PhysicalDeviceFeatures & setSparseResidency2Samples( vk::Bool32 sparseResidency2Samples_ )
{
sparseResidency2Samples = sparseResidency2Samples_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
+ PhysicalDeviceFeatures & setSparseResidency4Samples( vk::Bool32 sparseResidency4Samples_ )
{
sparseResidency4Samples = sparseResidency4Samples_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
+ PhysicalDeviceFeatures & setSparseResidency8Samples( vk::Bool32 sparseResidency8Samples_ )
{
sparseResidency8Samples = sparseResidency8Samples_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
+ PhysicalDeviceFeatures & setSparseResidency16Samples( vk::Bool32 sparseResidency16Samples_ )
{
sparseResidency16Samples = sparseResidency16Samples_;
return *this;
}
- PhysicalDeviceFeatures & setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
+ PhysicalDeviceFeatures & setSparseResidencyAliased( vk::Bool32 sparseResidencyAliased_ )
{
sparseResidencyAliased = sparseResidencyAliased_;
return *this;
}
- PhysicalDeviceFeatures & setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
+ PhysicalDeviceFeatures & setVariableMultisampleRate( vk::Bool32 variableMultisampleRate_ )
{
variableMultisampleRate = variableMultisampleRate_;
return *this;
}
- PhysicalDeviceFeatures & setInheritedQueries( Bool32 inheritedQueries_ )
+ PhysicalDeviceFeatures & setInheritedQueries( vk::Bool32 inheritedQueries_ )
{
inheritedQueries = inheritedQueries_;
return *this;
@@ -25803,92 +30065,135 @@
return !operator==( rhs );
}
- Bool32 robustBufferAccess;
- Bool32 fullDrawIndexUint32;
- Bool32 imageCubeArray;
- Bool32 independentBlend;
- Bool32 geometryShader;
- Bool32 tessellationShader;
- Bool32 sampleRateShading;
- Bool32 dualSrcBlend;
- Bool32 logicOp;
- Bool32 multiDrawIndirect;
- Bool32 drawIndirectFirstInstance;
- Bool32 depthClamp;
- Bool32 depthBiasClamp;
- Bool32 fillModeNonSolid;
- Bool32 depthBounds;
- Bool32 wideLines;
- Bool32 largePoints;
- Bool32 alphaToOne;
- Bool32 multiViewport;
- Bool32 samplerAnisotropy;
- Bool32 textureCompressionETC2;
- Bool32 textureCompressionASTC_LDR;
- Bool32 textureCompressionBC;
- Bool32 occlusionQueryPrecise;
- Bool32 pipelineStatisticsQuery;
- Bool32 vertexPipelineStoresAndAtomics;
- Bool32 fragmentStoresAndAtomics;
- Bool32 shaderTessellationAndGeometryPointSize;
- Bool32 shaderImageGatherExtended;
- Bool32 shaderStorageImageExtendedFormats;
- Bool32 shaderStorageImageMultisample;
- Bool32 shaderStorageImageReadWithoutFormat;
- Bool32 shaderStorageImageWriteWithoutFormat;
- Bool32 shaderUniformBufferArrayDynamicIndexing;
- Bool32 shaderSampledImageArrayDynamicIndexing;
- Bool32 shaderStorageBufferArrayDynamicIndexing;
- Bool32 shaderStorageImageArrayDynamicIndexing;
- Bool32 shaderClipDistance;
- Bool32 shaderCullDistance;
- Bool32 shaderFloat64;
- Bool32 shaderInt64;
- Bool32 shaderInt16;
- Bool32 shaderResourceResidency;
- Bool32 shaderResourceMinLod;
- Bool32 sparseBinding;
- Bool32 sparseResidencyBuffer;
- Bool32 sparseResidencyImage2D;
- Bool32 sparseResidencyImage3D;
- Bool32 sparseResidency2Samples;
- Bool32 sparseResidency4Samples;
- Bool32 sparseResidency8Samples;
- Bool32 sparseResidency16Samples;
- Bool32 sparseResidencyAliased;
- Bool32 variableMultisampleRate;
- Bool32 inheritedQueries;
+ public:
+ vk::Bool32 robustBufferAccess;
+ vk::Bool32 fullDrawIndexUint32;
+ vk::Bool32 imageCubeArray;
+ vk::Bool32 independentBlend;
+ vk::Bool32 geometryShader;
+ vk::Bool32 tessellationShader;
+ vk::Bool32 sampleRateShading;
+ vk::Bool32 dualSrcBlend;
+ vk::Bool32 logicOp;
+ vk::Bool32 multiDrawIndirect;
+ vk::Bool32 drawIndirectFirstInstance;
+ vk::Bool32 depthClamp;
+ vk::Bool32 depthBiasClamp;
+ vk::Bool32 fillModeNonSolid;
+ vk::Bool32 depthBounds;
+ vk::Bool32 wideLines;
+ vk::Bool32 largePoints;
+ vk::Bool32 alphaToOne;
+ vk::Bool32 multiViewport;
+ vk::Bool32 samplerAnisotropy;
+ vk::Bool32 textureCompressionETC2;
+ vk::Bool32 textureCompressionASTC_LDR;
+ vk::Bool32 textureCompressionBC;
+ vk::Bool32 occlusionQueryPrecise;
+ vk::Bool32 pipelineStatisticsQuery;
+ vk::Bool32 vertexPipelineStoresAndAtomics;
+ vk::Bool32 fragmentStoresAndAtomics;
+ vk::Bool32 shaderTessellationAndGeometryPointSize;
+ vk::Bool32 shaderImageGatherExtended;
+ vk::Bool32 shaderStorageImageExtendedFormats;
+ vk::Bool32 shaderStorageImageMultisample;
+ vk::Bool32 shaderStorageImageReadWithoutFormat;
+ vk::Bool32 shaderStorageImageWriteWithoutFormat;
+ vk::Bool32 shaderUniformBufferArrayDynamicIndexing;
+ vk::Bool32 shaderSampledImageArrayDynamicIndexing;
+ vk::Bool32 shaderStorageBufferArrayDynamicIndexing;
+ vk::Bool32 shaderStorageImageArrayDynamicIndexing;
+ vk::Bool32 shaderClipDistance;
+ vk::Bool32 shaderCullDistance;
+ vk::Bool32 shaderFloat64;
+ vk::Bool32 shaderInt64;
+ vk::Bool32 shaderInt16;
+ vk::Bool32 shaderResourceResidency;
+ vk::Bool32 shaderResourceMinLod;
+ vk::Bool32 sparseBinding;
+ vk::Bool32 sparseResidencyBuffer;
+ vk::Bool32 sparseResidencyImage2D;
+ vk::Bool32 sparseResidencyImage3D;
+ vk::Bool32 sparseResidency2Samples;
+ vk::Bool32 sparseResidency4Samples;
+ vk::Bool32 sparseResidency8Samples;
+ vk::Bool32 sparseResidency16Samples;
+ vk::Bool32 sparseResidencyAliased;
+ vk::Bool32 variableMultisampleRate;
+ vk::Bool32 inheritedQueries;
};
static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFeatures>::value, "struct wrapper is not a standard layout!" );
- struct DeviceCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , queueCreateInfoCount( queueCreateInfoCount_ )
- , pQueueCreateInfos( pQueueCreateInfos_ )
- , enabledLayerCount( enabledLayerCount_ )
- , ppEnabledLayerNames( ppEnabledLayerNames_ )
- , enabledExtensionCount( enabledExtensionCount_ )
- , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
- , pEnabledFeatures( pEnabledFeatures_ )
+ struct DeviceCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(),
+ uint32_t queueCreateInfoCount_ = 0,
+ const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
+ uint32_t enabledLayerCount_ = 0,
+ const char* const* ppEnabledLayerNames_ = nullptr,
+ uint32_t enabledExtensionCount_ = 0,
+ const char* const* ppEnabledExtensionNames_ = nullptr,
+ const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
+ : flags( flags_ )
+ , queueCreateInfoCount( queueCreateInfoCount_ )
+ , pQueueCreateInfos( pQueueCreateInfos_ )
+ , enabledLayerCount( enabledLayerCount_ )
+ , ppEnabledLayerNames( ppEnabledLayerNames_ )
+ , enabledExtensionCount( enabledExtensionCount_ )
+ , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+ , pEnabledFeatures( pEnabledFeatures_ )
+ {}
+
+ DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceCreateInfo*>(this) = rhs;
+ }
+
+ DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceCreateInfo;
+ const void* pNext = nullptr;
+ vk::DeviceCreateFlags flags;
+ uint32_t queueCreateInfoCount;
+ const vk::DeviceQueueCreateInfo* pQueueCreateInfos;
+ uint32_t enabledLayerCount;
+ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionCount;
+ const char* const* ppEnabledExtensionNames;
+ const vk::PhysicalDeviceFeatures* pEnabledFeatures;
+ };
+ static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceCreateInfo : public layout::DeviceCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(),
+ uint32_t queueCreateInfoCount_ = 0,
+ const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
+ uint32_t enabledLayerCount_ = 0,
+ const char* const* ppEnabledLayerNames_ = nullptr,
+ uint32_t enabledExtensionCount_ = 0,
+ const char* const* ppEnabledExtensionNames_ = nullptr,
+ const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
+ : layout::DeviceCreateInfo( flags_, queueCreateInfoCount_, pQueueCreateInfos_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_, pEnabledFeatures_ )
{}
DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
- }
+ : layout::DeviceCreateInfo( rhs )
+ {}
DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
+ layout::DeviceCreateInfo::operator=(rhs);
return *this;
}
@@ -25898,7 +30203,7 @@
return *this;
}
- DeviceCreateInfo & setFlags( DeviceCreateFlags flags_ )
+ DeviceCreateInfo & setFlags( vk::DeviceCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -25910,7 +30215,7 @@
return *this;
}
- DeviceCreateInfo & setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
+ DeviceCreateInfo & setPQueueCreateInfos( const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ )
{
pQueueCreateInfos = pQueueCreateInfos_;
return *this;
@@ -25940,7 +30245,7 @@
return *this;
}
- DeviceCreateInfo & setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
+ DeviceCreateInfo & setPEnabledFeatures( const vk::PhysicalDeviceFeatures* pEnabledFeatures_ )
{
pEnabledFeatures = pEnabledFeatures_;
return *this;
@@ -25976,35 +30281,52 @@
}
private:
- StructureType sType = StructureType::eDeviceCreateInfo;
-
- public:
- const void* pNext = nullptr;
- DeviceCreateFlags flags;
- uint32_t queueCreateInfoCount;
- const DeviceQueueCreateInfo* pQueueCreateInfos;
- uint32_t enabledLayerCount;
- const char* const* ppEnabledLayerNames;
- uint32_t enabledExtensionCount;
- const char* const* ppEnabledExtensionNames;
- const PhysicalDeviceFeatures* pEnabledFeatures;
+ using layout::DeviceCreateInfo::sType;
};
static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceEventInfoEXT
+ namespace layout
{
- DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
- : deviceEvent( deviceEvent_ )
+ struct DeviceEventInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug )
+ : deviceEvent( deviceEvent_ )
+ {}
+
+ DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDeviceEventInfoEXT*>(this) = rhs;
+ }
+
+ DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDeviceEventInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceEventInfoEXT;
+ const void* pNext = nullptr;
+ vk::DeviceEventTypeEXT deviceEvent;
+ };
+ static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceEventInfoEXT : public layout::DeviceEventInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug )
+ : layout::DeviceEventInfoEXT( deviceEvent_ )
{}
DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
- }
+ : layout::DeviceEventInfoEXT( rhs )
+ {}
DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
+ layout::DeviceEventInfoEXT::operator=(rhs);
return *this;
}
@@ -26014,7 +30336,7 @@
return *this;
}
- DeviceEventInfoEXT & setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
+ DeviceEventInfoEXT & setDeviceEvent( vk::DeviceEventTypeEXT deviceEvent_ )
{
deviceEvent = deviceEvent_;
return *this;
@@ -26043,28 +30365,52 @@
}
private:
- StructureType sType = StructureType::eDeviceEventInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DeviceEventTypeEXT deviceEvent;
+ using layout::DeviceEventInfoEXT::sType;
};
static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceEventInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGeneratedCommandsFeaturesNVX
+ namespace layout
{
- DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
- : computeBindingPointSupport( computeBindingPointSupport_ )
+ struct DeviceGeneratedCommandsFeaturesNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 )
+ : computeBindingPointSupport( computeBindingPointSupport_ )
+ {}
+
+ DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
+ }
+
+ DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
+ const void* pNext = nullptr;
+ vk::Bool32 computeBindingPointSupport;
+ };
+ static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGeneratedCommandsFeaturesNVX : public layout::DeviceGeneratedCommandsFeaturesNVX
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 )
+ : layout::DeviceGeneratedCommandsFeaturesNVX( computeBindingPointSupport_ )
{}
DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
- }
+ : layout::DeviceGeneratedCommandsFeaturesNVX( rhs )
+ {}
DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
+ layout::DeviceGeneratedCommandsFeaturesNVX::operator=(rhs);
return *this;
}
@@ -26074,7 +30420,7 @@
return *this;
}
- DeviceGeneratedCommandsFeaturesNVX & setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ )
+ DeviceGeneratedCommandsFeaturesNVX & setComputeBindingPointSupport( vk::Bool32 computeBindingPointSupport_ )
{
computeBindingPointSupport = computeBindingPointSupport_;
return *this;
@@ -26103,36 +30449,68 @@
}
private:
- StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
-
- public:
- const void* pNext = nullptr;
- Bool32 computeBindingPointSupport;
+ using layout::DeviceGeneratedCommandsFeaturesNVX::sType;
};
static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGeneratedCommandsFeaturesNVX>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGeneratedCommandsLimitsNVX
+ namespace layout
{
- DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
- uint32_t maxObjectEntryCounts_ = 0,
- uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
- uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
- uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
- : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
- , maxObjectEntryCounts( maxObjectEntryCounts_ )
- , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
- , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
- , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
+ struct DeviceGeneratedCommandsLimitsNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
+ uint32_t maxObjectEntryCounts_ = 0,
+ uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
+ uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
+ uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
+ : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
+ , maxObjectEntryCounts( maxObjectEntryCounts_ )
+ , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
+ , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
+ , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
+ {}
+
+ DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
+ }
+
+ DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
+ const void* pNext = nullptr;
+ uint32_t maxIndirectCommandsLayoutTokenCount;
+ uint32_t maxObjectEntryCounts;
+ uint32_t minSequenceCountBufferOffsetAlignment;
+ uint32_t minSequenceIndexBufferOffsetAlignment;
+ uint32_t minCommandsTokenBufferOffsetAlignment;
+ };
+ static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGeneratedCommandsLimitsNVX : public layout::DeviceGeneratedCommandsLimitsNVX
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
+ uint32_t maxObjectEntryCounts_ = 0,
+ uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
+ uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
+ uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
+ : layout::DeviceGeneratedCommandsLimitsNVX( maxIndirectCommandsLayoutTokenCount_, maxObjectEntryCounts_, minSequenceCountBufferOffsetAlignment_, minSequenceIndexBufferOffsetAlignment_, minCommandsTokenBufferOffsetAlignment_ )
{}
DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
- }
+ : layout::DeviceGeneratedCommandsLimitsNVX( rhs )
+ {}
DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
+ layout::DeviceGeneratedCommandsLimitsNVX::operator=(rhs);
return *this;
}
@@ -26199,34 +30577,56 @@
}
private:
- StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
-
- public:
- const void* pNext = nullptr;
- uint32_t maxIndirectCommandsLayoutTokenCount;
- uint32_t maxObjectEntryCounts;
- uint32_t minSequenceCountBufferOffsetAlignment;
- uint32_t minSequenceIndexBufferOffsetAlignment;
- uint32_t minCommandsTokenBufferOffsetAlignment;
+ using layout::DeviceGeneratedCommandsLimitsNVX::sType;
};
static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGeneratedCommandsLimitsNVX>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupBindSparseInfo
+ namespace layout
{
- DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
- uint32_t memoryDeviceIndex_ = 0 )
- : resourceDeviceIndex( resourceDeviceIndex_ )
- , memoryDeviceIndex( memoryDeviceIndex_ )
+ struct DeviceGroupBindSparseInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
+ uint32_t memoryDeviceIndex_ = 0 )
+ : resourceDeviceIndex( resourceDeviceIndex_ )
+ , memoryDeviceIndex( memoryDeviceIndex_ )
+ {}
+
+ DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this) = rhs;
+ }
+
+ DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
+ const void* pNext = nullptr;
+ uint32_t resourceDeviceIndex;
+ uint32_t memoryDeviceIndex;
+ };
+ static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupBindSparseInfo : public layout::DeviceGroupBindSparseInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
+ uint32_t memoryDeviceIndex_ = 0 )
+ : layout::DeviceGroupBindSparseInfo( resourceDeviceIndex_, memoryDeviceIndex_ )
{}
DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
- }
+ : layout::DeviceGroupBindSparseInfo( rhs )
+ {}
DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
+ layout::DeviceGroupBindSparseInfo::operator=(rhs);
return *this;
}
@@ -26272,29 +30672,52 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupBindSparseInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t resourceDeviceIndex;
- uint32_t memoryDeviceIndex;
+ using layout::DeviceGroupBindSparseInfo::sType;
};
static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupBindSparseInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupCommandBufferBeginInfo
+ namespace layout
{
- DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
- : deviceMask( deviceMask_ )
+ struct DeviceGroupCommandBufferBeginInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
+ : deviceMask( deviceMask_ )
+ {}
+
+ DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
+ }
+
+ DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
+ const void* pNext = nullptr;
+ uint32_t deviceMask;
+ };
+ static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupCommandBufferBeginInfo : public layout::DeviceGroupCommandBufferBeginInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 )
+ : layout::DeviceGroupCommandBufferBeginInfo( deviceMask_ )
{}
DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
- }
+ : layout::DeviceGroupCommandBufferBeginInfo( rhs )
+ {}
DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
+ layout::DeviceGroupCommandBufferBeginInfo::operator=(rhs);
return *this;
}
@@ -26333,30 +30756,56 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t deviceMask;
+ using layout::DeviceGroupCommandBufferBeginInfo::sType;
};
static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupCommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupDeviceCreateInfo
+ namespace layout
{
- DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
- const PhysicalDevice* pPhysicalDevices_ = nullptr )
- : physicalDeviceCount( physicalDeviceCount_ )
- , pPhysicalDevices( pPhysicalDevices_ )
+ struct DeviceGroupDeviceCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
+ const vk::PhysicalDevice* pPhysicalDevices_ = nullptr )
+ : physicalDeviceCount( physicalDeviceCount_ )
+ , pPhysicalDevices( pPhysicalDevices_ )
+ {}
+
+ DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
+ }
+
+ DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
+ const void* pNext = nullptr;
+ uint32_t physicalDeviceCount;
+ const vk::PhysicalDevice* pPhysicalDevices;
+ };
+ static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupDeviceCreateInfo : public layout::DeviceGroupDeviceCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
+ const vk::PhysicalDevice* pPhysicalDevices_ = nullptr )
+ : layout::DeviceGroupDeviceCreateInfo( physicalDeviceCount_, pPhysicalDevices_ )
{}
DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
- }
+ : layout::DeviceGroupDeviceCreateInfo( rhs )
+ {}
DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
+ layout::DeviceGroupDeviceCreateInfo::operator=(rhs);
return *this;
}
@@ -26372,7 +30821,7 @@
return *this;
}
- DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ )
+ DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const vk::PhysicalDevice* pPhysicalDevices_ )
{
pPhysicalDevices = pPhysicalDevices_;
return *this;
@@ -26402,17 +30851,55 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t physicalDeviceCount;
- const PhysicalDevice* pPhysicalDevices;
+ using layout::DeviceGroupDeviceCreateInfo::sType;
};
static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupDeviceCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupPresentCapabilitiesKHR
+ namespace layout
{
+ struct DeviceGroupPresentCapabilitiesKHR
+ {
+ protected:
+ DeviceGroupPresentCapabilitiesKHR()
+ {}
+
+ DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this) = rhs;
+ }
+
+ DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
+ const void* pNext = nullptr;
+ uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+ vk::DeviceGroupPresentModeFlagsKHR modes;
+ };
+ static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupPresentCapabilitiesKHR : public layout::DeviceGroupPresentCapabilitiesKHR
+ {
+ DeviceGroupPresentCapabilitiesKHR()
+ : layout::DeviceGroupPresentCapabilitiesKHR()
+ {}
+
+ DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs )
+ : layout::DeviceGroupPresentCapabilitiesKHR( rhs )
+ {}
+
+ DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs )
+ {
+ layout::DeviceGroupPresentCapabilitiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkDeviceGroupPresentCapabilitiesKHR const&() const
{
return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>( this );
@@ -26437,33 +30924,60 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
- DeviceGroupPresentModeFlagsKHR modes;
+ using layout::DeviceGroupPresentCapabilitiesKHR::sType;
};
static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupPresentCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupPresentInfoKHR
+ namespace layout
{
- DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
- const uint32_t* pDeviceMasks_ = nullptr,
- DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal )
- : swapchainCount( swapchainCount_ )
- , pDeviceMasks( pDeviceMasks_ )
- , mode( mode_ )
+ struct DeviceGroupPresentInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
+ const uint32_t* pDeviceMasks_ = nullptr,
+ vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal )
+ : swapchainCount( swapchainCount_ )
+ , pDeviceMasks( pDeviceMasks_ )
+ , mode( mode_ )
+ {}
+
+ DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
+ }
+
+ DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t swapchainCount;
+ const uint32_t* pDeviceMasks;
+ vk::DeviceGroupPresentModeFlagBitsKHR mode;
+ };
+ static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupPresentInfoKHR : public layout::DeviceGroupPresentInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0,
+ const uint32_t* pDeviceMasks_ = nullptr,
+ vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal )
+ : layout::DeviceGroupPresentInfoKHR( swapchainCount_, pDeviceMasks_, mode_ )
{}
DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
- }
+ : layout::DeviceGroupPresentInfoKHR( rhs )
+ {}
DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
+ layout::DeviceGroupPresentInfoKHR::operator=(rhs);
return *this;
}
@@ -26485,7 +30999,7 @@
return *this;
}
- DeviceGroupPresentInfoKHR & setMode( DeviceGroupPresentModeFlagBitsKHR mode_ )
+ DeviceGroupPresentInfoKHR & setMode( vk::DeviceGroupPresentModeFlagBitsKHR mode_ )
{
mode = mode_;
return *this;
@@ -26516,34 +31030,60 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupPresentInfoKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t swapchainCount;
- const uint32_t* pDeviceMasks;
- DeviceGroupPresentModeFlagBitsKHR mode;
+ using layout::DeviceGroupPresentInfoKHR::sType;
};
static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupRenderPassBeginInfo
+ namespace layout
{
- DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
- uint32_t deviceRenderAreaCount_ = 0,
- const Rect2D* pDeviceRenderAreas_ = nullptr )
- : deviceMask( deviceMask_ )
- , deviceRenderAreaCount( deviceRenderAreaCount_ )
- , pDeviceRenderAreas( pDeviceRenderAreas_ )
+ struct DeviceGroupRenderPassBeginInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
+ uint32_t deviceRenderAreaCount_ = 0,
+ const vk::Rect2D* pDeviceRenderAreas_ = nullptr )
+ : deviceMask( deviceMask_ )
+ , deviceRenderAreaCount( deviceRenderAreaCount_ )
+ , pDeviceRenderAreas( pDeviceRenderAreas_ )
+ {}
+
+ DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
+ }
+
+ DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
+ const void* pNext = nullptr;
+ uint32_t deviceMask;
+ uint32_t deviceRenderAreaCount;
+ const vk::Rect2D* pDeviceRenderAreas;
+ };
+ static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupRenderPassBeginInfo : public layout::DeviceGroupRenderPassBeginInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0,
+ uint32_t deviceRenderAreaCount_ = 0,
+ const vk::Rect2D* pDeviceRenderAreas_ = nullptr )
+ : layout::DeviceGroupRenderPassBeginInfo( deviceMask_, deviceRenderAreaCount_, pDeviceRenderAreas_ )
{}
DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
- }
+ : layout::DeviceGroupRenderPassBeginInfo( rhs )
+ {}
DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
+ layout::DeviceGroupRenderPassBeginInfo::operator=(rhs);
return *this;
}
@@ -26565,7 +31105,7 @@
return *this;
}
- DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ )
+ DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const vk::Rect2D* pDeviceRenderAreas_ )
{
pDeviceRenderAreas = pDeviceRenderAreas_;
return *this;
@@ -26596,40 +31136,72 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t deviceMask;
- uint32_t deviceRenderAreaCount;
- const Rect2D* pDeviceRenderAreas;
+ using layout::DeviceGroupRenderPassBeginInfo::sType;
};
static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupRenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupSubmitInfo
+ namespace layout
{
- DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
- const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
- uint32_t commandBufferCount_ = 0,
- const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
- uint32_t signalSemaphoreCount_ = 0,
- const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
- : waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
- , commandBufferCount( commandBufferCount_ )
- , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
- , signalSemaphoreCount( signalSemaphoreCount_ )
- , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
+ struct DeviceGroupSubmitInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+ const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
+ uint32_t commandBufferCount_ = 0,
+ const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
+ , commandBufferCount( commandBufferCount_ )
+ , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
+ , signalSemaphoreCount( signalSemaphoreCount_ )
+ , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
+ {}
+
+ DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this) = rhs;
+ }
+
+ DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupSubmitInfo;
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreCount;
+ const uint32_t* pWaitSemaphoreDeviceIndices;
+ uint32_t commandBufferCount;
+ const uint32_t* pCommandBufferDeviceMasks;
+ uint32_t signalSemaphoreCount;
+ const uint32_t* pSignalSemaphoreDeviceIndices;
+ };
+ static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupSubmitInfo : public layout::DeviceGroupSubmitInfo
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+ const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
+ uint32_t commandBufferCount_ = 0,
+ const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
+ : layout::DeviceGroupSubmitInfo( waitSemaphoreCount_, pWaitSemaphoreDeviceIndices_, commandBufferCount_, pCommandBufferDeviceMasks_, signalSemaphoreCount_, pSignalSemaphoreDeviceIndices_ )
{}
DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
- }
+ : layout::DeviceGroupSubmitInfo( rhs )
+ {}
DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
+ layout::DeviceGroupSubmitInfo::operator=(rhs);
return *this;
}
@@ -26703,33 +31275,52 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupSubmitInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t waitSemaphoreCount;
- const uint32_t* pWaitSemaphoreDeviceIndices;
- uint32_t commandBufferCount;
- const uint32_t* pCommandBufferDeviceMasks;
- uint32_t signalSemaphoreCount;
- const uint32_t* pSignalSemaphoreDeviceIndices;
+ using layout::DeviceGroupSubmitInfo::sType;
};
static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupSubmitInfo>::value, "struct wrapper is not a standard layout!" );
- struct DeviceGroupSwapchainCreateInfoKHR
+ namespace layout
{
- DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = DeviceGroupPresentModeFlagsKHR() )
- : modes( modes_ )
+ struct DeviceGroupSwapchainCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() )
+ : modes( modes_ )
+ {}
+
+ DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
+ }
+
+ DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::DeviceGroupPresentModeFlagsKHR modes;
+ };
+ static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceGroupSwapchainCreateInfoKHR : public layout::DeviceGroupSwapchainCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() )
+ : layout::DeviceGroupSwapchainCreateInfoKHR( modes_ )
{}
DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
- }
+ : layout::DeviceGroupSwapchainCreateInfoKHR( rhs )
+ {}
DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
+ layout::DeviceGroupSwapchainCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -26739,7 +31330,7 @@
return *this;
}
- DeviceGroupSwapchainCreateInfoKHR & setModes( DeviceGroupPresentModeFlagsKHR modes_ )
+ DeviceGroupSwapchainCreateInfoKHR & setModes( vk::DeviceGroupPresentModeFlagsKHR modes_ )
{
modes = modes_;
return *this;
@@ -26768,28 +31359,52 @@
}
private:
- StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- DeviceGroupPresentModeFlagsKHR modes;
+ using layout::DeviceGroupSwapchainCreateInfoKHR::sType;
};
static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceGroupSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct DeviceMemoryOverallocationCreateInfoAMD
+ namespace layout
{
- DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault )
- : overallocationBehavior( overallocationBehavior_ )
+ struct DeviceMemoryOverallocationCreateInfoAMD
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault )
+ : overallocationBehavior( overallocationBehavior_ )
+ {}
+
+ DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
+ }
+
+ DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
+ const void* pNext = nullptr;
+ vk::MemoryOverallocationBehaviorAMD overallocationBehavior;
+ };
+ static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceMemoryOverallocationCreateInfoAMD : public layout::DeviceMemoryOverallocationCreateInfoAMD
+ {
+ VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault )
+ : layout::DeviceMemoryOverallocationCreateInfoAMD( overallocationBehavior_ )
{}
DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
- }
+ : layout::DeviceMemoryOverallocationCreateInfoAMD( rhs )
+ {}
DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
+ layout::DeviceMemoryOverallocationCreateInfoAMD::operator=(rhs);
return *this;
}
@@ -26799,7 +31414,7 @@
return *this;
}
- DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ )
+ DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ )
{
overallocationBehavior = overallocationBehavior_;
return *this;
@@ -26828,28 +31443,52 @@
}
private:
- StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD;
-
- public:
- const void* pNext = nullptr;
- MemoryOverallocationBehaviorAMD overallocationBehavior;
+ using layout::DeviceMemoryOverallocationCreateInfoAMD::sType;
};
static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceMemoryOverallocationCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
- struct DeviceQueueGlobalPriorityCreateInfoEXT
+ namespace layout
{
- DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
- : globalPriority( globalPriority_ )
+ struct DeviceQueueGlobalPriorityCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow )
+ : globalPriority( globalPriority_ )
+ {}
+
+ DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
+ }
+
+ DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::QueueGlobalPriorityEXT globalPriority;
+ };
+ static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceQueueGlobalPriorityCreateInfoEXT : public layout::DeviceQueueGlobalPriorityCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow )
+ : layout::DeviceQueueGlobalPriorityCreateInfoEXT( globalPriority_ )
{}
DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
- }
+ : layout::DeviceQueueGlobalPriorityCreateInfoEXT( rhs )
+ {}
DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
+ layout::DeviceQueueGlobalPriorityCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -26859,7 +31498,7 @@
return *this;
}
- DeviceQueueGlobalPriorityCreateInfoEXT & setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
+ DeviceQueueGlobalPriorityCreateInfoEXT & setGlobalPriority( vk::QueueGlobalPriorityEXT globalPriority_ )
{
globalPriority = globalPriority_;
return *this;
@@ -26888,32 +31527,60 @@
}
private:
- StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- QueueGlobalPriorityEXT globalPriority;
+ using layout::DeviceQueueGlobalPriorityCreateInfoEXT::sType;
};
static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceQueueGlobalPriorityCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DeviceQueueInfo2
+ namespace layout
{
- DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(),
- uint32_t queueFamilyIndex_ = 0,
- uint32_t queueIndex_ = 0 )
- : flags( flags_ )
- , queueFamilyIndex( queueFamilyIndex_ )
- , queueIndex( queueIndex_ )
+ struct DeviceQueueInfo2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0,
+ uint32_t queueIndex_ = 0 )
+ : flags( flags_ )
+ , queueFamilyIndex( queueFamilyIndex_ )
+ , queueIndex( queueIndex_ )
+ {}
+
+ DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkDeviceQueueInfo2*>(this) = rhs;
+ }
+
+ DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkDeviceQueueInfo2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDeviceQueueInfo2;
+ const void* pNext = nullptr;
+ vk::DeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queueIndex;
+ };
+ static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DeviceQueueInfo2 : public layout::DeviceQueueInfo2
+ {
+ VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(),
+ uint32_t queueFamilyIndex_ = 0,
+ uint32_t queueIndex_ = 0 )
+ : layout::DeviceQueueInfo2( flags_, queueFamilyIndex_, queueIndex_ )
{}
DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
- }
+ : layout::DeviceQueueInfo2( rhs )
+ {}
DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
+ layout::DeviceQueueInfo2::operator=(rhs);
return *this;
}
@@ -26923,7 +31590,7 @@
return *this;
}
- DeviceQueueInfo2 & setFlags( DeviceQueueCreateFlags flags_ )
+ DeviceQueueInfo2 & setFlags( vk::DeviceQueueCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -26966,21 +31633,16 @@
}
private:
- StructureType sType = StructureType::eDeviceQueueInfo2;
-
- public:
- const void* pNext = nullptr;
- DeviceQueueCreateFlags flags;
- uint32_t queueFamilyIndex;
- uint32_t queueIndex;
+ using layout::DeviceQueueInfo2::sType;
};
static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DeviceQueueInfo2>::value, "struct wrapper is not a standard layout!" );
struct DispatchIndirectCommand
{
- DispatchIndirectCommand( uint32_t x_ = 0,
- uint32_t y_ = 0,
- uint32_t z_ = 0 )
+ VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( uint32_t x_ = 0,
+ uint32_t y_ = 0,
+ uint32_t z_ = 0 )
: x( x_ )
, y( y_ )
, z( z_ )
@@ -26988,12 +31650,12 @@
DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
+ *reinterpret_cast<VkDispatchIndirectCommand*>(this) = rhs;
}
DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
+ *reinterpret_cast<VkDispatchIndirectCommand*>(this) = rhs;
return *this;
}
@@ -27037,26 +31699,55 @@
return !operator==( rhs );
}
+ public:
uint32_t x;
uint32_t y;
uint32_t z;
};
static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DispatchIndirectCommand>::value, "struct wrapper is not a standard layout!" );
- struct DisplayEventInfoEXT
+ namespace layout
{
- DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
- : displayEvent( displayEvent_ )
+ struct DisplayEventInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut )
+ : displayEvent( displayEvent_ )
+ {}
+
+ DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDisplayEventInfoEXT*>(this) = rhs;
+ }
+
+ DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDisplayEventInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayEventInfoEXT;
+ const void* pNext = nullptr;
+ vk::DisplayEventTypeEXT displayEvent;
+ };
+ static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayEventInfoEXT : public layout::DisplayEventInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut )
+ : layout::DisplayEventInfoEXT( displayEvent_ )
{}
DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
- }
+ : layout::DisplayEventInfoEXT( rhs )
+ {}
DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
+ layout::DisplayEventInfoEXT::operator=(rhs);
return *this;
}
@@ -27066,7 +31757,7 @@
return *this;
}
- DisplayEventInfoEXT & setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
+ DisplayEventInfoEXT & setDisplayEvent( vk::DisplayEventTypeEXT displayEvent_ )
{
displayEvent = displayEvent_;
return *this;
@@ -27095,34 +31786,31 @@
}
private:
- StructureType sType = StructureType::eDisplayEventInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DisplayEventTypeEXT displayEvent;
+ using layout::DisplayEventInfoEXT::sType;
};
static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayEventInfoEXT>::value, "struct wrapper is not a standard layout!" );
struct DisplayModeParametersKHR
{
- DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(),
- uint32_t refreshRate_ = 0 )
+ VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( vk::Extent2D visibleRegion_ = vk::Extent2D(),
+ uint32_t refreshRate_ = 0 )
: visibleRegion( visibleRegion_ )
, refreshRate( refreshRate_ )
{}
DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
+ *reinterpret_cast<VkDisplayModeParametersKHR*>(this) = rhs;
}
DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
+ *reinterpret_cast<VkDisplayModeParametersKHR*>(this) = rhs;
return *this;
}
- DisplayModeParametersKHR & setVisibleRegion( Extent2D visibleRegion_ )
+ DisplayModeParametersKHR & setVisibleRegion( vk::Extent2D visibleRegion_ )
{
visibleRegion = visibleRegion_;
return *this;
@@ -27155,27 +31843,58 @@
return !operator==( rhs );
}
- Extent2D visibleRegion;
+ public:
+ vk::Extent2D visibleRegion;
uint32_t refreshRate;
};
static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayModeParametersKHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayModeCreateInfoKHR
+ namespace layout
{
- DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(),
- DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
- : flags( flags_ )
- , parameters( parameters_ )
+ struct DisplayModeCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(),
+ vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() )
+ : flags( flags_ )
+ , parameters( parameters_ )
+ {}
+
+ DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
+ }
+
+ DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::DisplayModeCreateFlagsKHR flags;
+ vk::DisplayModeParametersKHR parameters;
+ };
+ static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayModeCreateInfoKHR : public layout::DisplayModeCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(),
+ vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() )
+ : layout::DisplayModeCreateInfoKHR( flags_, parameters_ )
{}
DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
- }
+ : layout::DisplayModeCreateInfoKHR( rhs )
+ {}
DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
+ layout::DisplayModeCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -27185,13 +31904,13 @@
return *this;
}
- DisplayModeCreateInfoKHR & setFlags( DisplayModeCreateFlagsKHR flags_ )
+ DisplayModeCreateInfoKHR & setFlags( vk::DisplayModeCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
}
- DisplayModeCreateInfoKHR & setParameters( DisplayModeParametersKHR parameters_ )
+ DisplayModeCreateInfoKHR & setParameters( vk::DisplayModeParametersKHR parameters_ )
{
parameters = parameters_;
return *this;
@@ -27221,17 +31940,27 @@
}
private:
- StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- DisplayModeCreateFlagsKHR flags;
- DisplayModeParametersKHR parameters;
+ using layout::DisplayModeCreateInfoKHR::sType;
};
static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayModeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct DisplayModePropertiesKHR
{
+ DisplayModePropertiesKHR()
+ {}
+
+ DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayModePropertiesKHR*>(this) = rhs;
+ }
+
+ DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayModePropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
operator VkDisplayModePropertiesKHR const&() const
{
return *reinterpret_cast<const VkDisplayModePropertiesKHR*>( this );
@@ -27253,13 +31982,56 @@
return !operator==( rhs );
}
- DisplayModeKHR displayMode;
- DisplayModeParametersKHR parameters;
+ public:
+ vk::DisplayModeKHR displayMode;
+ vk::DisplayModeParametersKHR parameters;
};
static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayModePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayModeProperties2KHR
+ namespace layout
{
+ struct DisplayModeProperties2KHR
+ {
+ protected:
+ DisplayModeProperties2KHR()
+ {}
+
+ DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayModeProperties2KHR*>(this) = rhs;
+ }
+
+ DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayModeProperties2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayModeProperties2KHR;
+ void* pNext = nullptr;
+ vk::DisplayModePropertiesKHR displayModeProperties;
+ };
+ static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayModeProperties2KHR : public layout::DisplayModeProperties2KHR
+ {
+ DisplayModeProperties2KHR()
+ : layout::DisplayModeProperties2KHR()
+ {}
+
+ DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs )
+ : layout::DisplayModeProperties2KHR( rhs )
+ {}
+
+ DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs )
+ {
+ layout::DisplayModeProperties2KHR::operator=(rhs);
+ return *this;
+ }
+
operator VkDisplayModeProperties2KHR const&() const
{
return *reinterpret_cast<const VkDisplayModeProperties2KHR*>( this );
@@ -27283,16 +32055,54 @@
}
private:
- StructureType sType = StructureType::eDisplayModeProperties2KHR;
-
- public:
- void* pNext = nullptr;
- DisplayModePropertiesKHR displayModeProperties;
+ using layout::DisplayModeProperties2KHR::sType;
};
static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayModeProperties2KHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayNativeHdrSurfaceCapabilitiesAMD
+ namespace layout
{
+ struct DisplayNativeHdrSurfaceCapabilitiesAMD
+ {
+ protected:
+ DisplayNativeHdrSurfaceCapabilitiesAMD()
+ {}
+
+ DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs )
+ {
+ *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this) = rhs;
+ }
+
+ DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs )
+ {
+ *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
+ void* pNext = nullptr;
+ vk::Bool32 localDimmingSupport;
+ };
+ static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayNativeHdrSurfaceCapabilitiesAMD : public layout::DisplayNativeHdrSurfaceCapabilitiesAMD
+ {
+ DisplayNativeHdrSurfaceCapabilitiesAMD()
+ : layout::DisplayNativeHdrSurfaceCapabilitiesAMD()
+ {}
+
+ DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs )
+ : layout::DisplayNativeHdrSurfaceCapabilitiesAMD( rhs )
+ {}
+
+ DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs )
+ {
+ layout::DisplayNativeHdrSurfaceCapabilitiesAMD::operator=(rhs);
+ return *this;
+ }
+
operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const
{
return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this );
@@ -27316,16 +32126,27 @@
}
private:
- StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD;
-
- public:
- void* pNext = nullptr;
- Bool32 localDimmingSupport;
+ using layout::DisplayNativeHdrSurfaceCapabilitiesAMD::sType;
};
static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayNativeHdrSurfaceCapabilitiesAMD>::value, "struct wrapper is not a standard layout!" );
struct DisplayPlaneCapabilitiesKHR
{
+ DisplayPlaneCapabilitiesKHR()
+ {}
+
+ DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this) = rhs;
+ }
+
+ DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this) = rhs;
+ return *this;
+ }
+
operator VkDisplayPlaneCapabilitiesKHR const&() const
{
return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>( this );
@@ -27354,20 +32175,63 @@
return !operator==( rhs );
}
- DisplayPlaneAlphaFlagsKHR supportedAlpha;
- Offset2D minSrcPosition;
- Offset2D maxSrcPosition;
- Extent2D minSrcExtent;
- Extent2D maxSrcExtent;
- Offset2D minDstPosition;
- Offset2D maxDstPosition;
- Extent2D minDstExtent;
- Extent2D maxDstExtent;
+ public:
+ vk::DisplayPlaneAlphaFlagsKHR supportedAlpha;
+ vk::Offset2D minSrcPosition;
+ vk::Offset2D maxSrcPosition;
+ vk::Extent2D minSrcExtent;
+ vk::Extent2D maxSrcExtent;
+ vk::Offset2D minDstPosition;
+ vk::Offset2D maxDstPosition;
+ vk::Extent2D minDstExtent;
+ vk::Extent2D maxDstExtent;
};
static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPlaneCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayPlaneCapabilities2KHR
+ namespace layout
{
+ struct DisplayPlaneCapabilities2KHR
+ {
+ protected:
+ DisplayPlaneCapabilities2KHR()
+ {}
+
+ DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this) = rhs;
+ }
+
+ DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
+ void* pNext = nullptr;
+ vk::DisplayPlaneCapabilitiesKHR capabilities;
+ };
+ static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayPlaneCapabilities2KHR : public layout::DisplayPlaneCapabilities2KHR
+ {
+ DisplayPlaneCapabilities2KHR()
+ : layout::DisplayPlaneCapabilities2KHR()
+ {}
+
+ DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs )
+ : layout::DisplayPlaneCapabilities2KHR( rhs )
+ {}
+
+ DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs )
+ {
+ layout::DisplayPlaneCapabilities2KHR::operator=(rhs);
+ return *this;
+ }
+
operator VkDisplayPlaneCapabilities2KHR const&() const
{
return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>( this );
@@ -27391,30 +32255,56 @@
}
private:
- StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR;
-
- public:
- void* pNext = nullptr;
- DisplayPlaneCapabilitiesKHR capabilities;
+ using layout::DisplayPlaneCapabilities2KHR::sType;
};
static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPlaneCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayPlaneInfo2KHR
+ namespace layout
{
- DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = DisplayModeKHR(),
- uint32_t planeIndex_ = 0 )
- : mode( mode_ )
- , planeIndex( planeIndex_ )
+ struct DisplayPlaneInfo2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(),
+ uint32_t planeIndex_ = 0 )
+ : mode( mode_ )
+ , planeIndex( planeIndex_ )
+ {}
+
+ DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this) = rhs;
+ }
+
+ DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
+ const void* pNext = nullptr;
+ vk::DisplayModeKHR mode;
+ uint32_t planeIndex;
+ };
+ static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayPlaneInfo2KHR : public layout::DisplayPlaneInfo2KHR
+ {
+ VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(),
+ uint32_t planeIndex_ = 0 )
+ : layout::DisplayPlaneInfo2KHR( mode_, planeIndex_ )
{}
DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
- }
+ : layout::DisplayPlaneInfo2KHR( rhs )
+ {}
DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
+ layout::DisplayPlaneInfo2KHR::operator=(rhs);
return *this;
}
@@ -27424,7 +32314,7 @@
return *this;
}
- DisplayPlaneInfo2KHR & setMode( DisplayModeKHR mode_ )
+ DisplayPlaneInfo2KHR & setMode( vk::DisplayModeKHR mode_ )
{
mode = mode_;
return *this;
@@ -27460,17 +32350,27 @@
}
private:
- StructureType sType = StructureType::eDisplayPlaneInfo2KHR;
-
- public:
- const void* pNext = nullptr;
- DisplayModeKHR mode;
- uint32_t planeIndex;
+ using layout::DisplayPlaneInfo2KHR::sType;
};
static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPlaneInfo2KHR>::value, "struct wrapper is not a standard layout!" );
struct DisplayPlanePropertiesKHR
{
+ DisplayPlanePropertiesKHR()
+ {}
+
+ DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this) = rhs;
+ }
+
+ DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
operator VkDisplayPlanePropertiesKHR const&() const
{
return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>( this );
@@ -27492,13 +32392,56 @@
return !operator==( rhs );
}
- DisplayKHR currentDisplay;
+ public:
+ vk::DisplayKHR currentDisplay;
uint32_t currentStackIndex;
};
static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPlanePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayPlaneProperties2KHR
+ namespace layout
{
+ struct DisplayPlaneProperties2KHR
+ {
+ protected:
+ DisplayPlaneProperties2KHR()
+ {}
+
+ DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
+ }
+
+ DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
+ void* pNext = nullptr;
+ vk::DisplayPlanePropertiesKHR displayPlaneProperties;
+ };
+ static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayPlaneProperties2KHR : public layout::DisplayPlaneProperties2KHR
+ {
+ DisplayPlaneProperties2KHR()
+ : layout::DisplayPlaneProperties2KHR()
+ {}
+
+ DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs )
+ : layout::DisplayPlaneProperties2KHR( rhs )
+ {}
+
+ DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs )
+ {
+ layout::DisplayPlaneProperties2KHR::operator=(rhs);
+ return *this;
+ }
+
operator VkDisplayPlaneProperties2KHR const&() const
{
return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>( this );
@@ -27522,28 +32465,52 @@
}
private:
- StructureType sType = StructureType::eDisplayPlaneProperties2KHR;
-
- public:
- void* pNext = nullptr;
- DisplayPlanePropertiesKHR displayPlaneProperties;
+ using layout::DisplayPlaneProperties2KHR::sType;
};
static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPlaneProperties2KHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayPowerInfoEXT
+ namespace layout
{
- DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
- : powerState( powerState_ )
+ struct DisplayPowerInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff )
+ : powerState( powerState_ )
+ {}
+
+ DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPowerInfoEXT*>(this) = rhs;
+ }
+
+ DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPowerInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayPowerInfoEXT;
+ const void* pNext = nullptr;
+ vk::DisplayPowerStateEXT powerState;
+ };
+ static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayPowerInfoEXT : public layout::DisplayPowerInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff )
+ : layout::DisplayPowerInfoEXT( powerState_ )
{}
DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
- }
+ : layout::DisplayPowerInfoEXT( rhs )
+ {}
DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
+ layout::DisplayPowerInfoEXT::operator=(rhs);
return *this;
}
@@ -27553,7 +32520,7 @@
return *this;
}
- DisplayPowerInfoEXT & setPowerState( DisplayPowerStateEXT powerState_ )
+ DisplayPowerInfoEXT & setPowerState( vk::DisplayPowerStateEXT powerState_ )
{
powerState = powerState_;
return *this;
@@ -27582,32 +32549,60 @@
}
private:
- StructureType sType = StructureType::eDisplayPowerInfoEXT;
-
- public:
- const void* pNext = nullptr;
- DisplayPowerStateEXT powerState;
+ using layout::DisplayPowerInfoEXT::sType;
};
static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPowerInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct DisplayPresentInfoKHR
+ namespace layout
{
- DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(),
- Rect2D dstRect_ = Rect2D(),
- Bool32 persistent_ = 0 )
- : srcRect( srcRect_ )
- , dstRect( dstRect_ )
- , persistent( persistent_ )
+ struct DisplayPresentInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(),
+ vk::Rect2D dstRect_ = vk::Rect2D(),
+ vk::Bool32 persistent_ = 0 )
+ : srcRect( srcRect_ )
+ , dstRect( dstRect_ )
+ , persistent( persistent_ )
+ {}
+
+ DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPresentInfoKHR*>(this) = rhs;
+ }
+
+ DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPresentInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayPresentInfoKHR;
+ const void* pNext = nullptr;
+ vk::Rect2D srcRect;
+ vk::Rect2D dstRect;
+ vk::Bool32 persistent;
+ };
+ static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayPresentInfoKHR : public layout::DisplayPresentInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(),
+ vk::Rect2D dstRect_ = vk::Rect2D(),
+ vk::Bool32 persistent_ = 0 )
+ : layout::DisplayPresentInfoKHR( srcRect_, dstRect_, persistent_ )
{}
DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
- }
+ : layout::DisplayPresentInfoKHR( rhs )
+ {}
DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
+ layout::DisplayPresentInfoKHR::operator=(rhs);
return *this;
}
@@ -27617,19 +32612,19 @@
return *this;
}
- DisplayPresentInfoKHR & setSrcRect( Rect2D srcRect_ )
+ DisplayPresentInfoKHR & setSrcRect( vk::Rect2D srcRect_ )
{
srcRect = srcRect_;
return *this;
}
- DisplayPresentInfoKHR & setDstRect( Rect2D dstRect_ )
+ DisplayPresentInfoKHR & setDstRect( vk::Rect2D dstRect_ )
{
dstRect = dstRect_;
return *this;
}
- DisplayPresentInfoKHR & setPersistent( Bool32 persistent_ )
+ DisplayPresentInfoKHR & setPersistent( vk::Bool32 persistent_ )
{
persistent = persistent_;
return *this;
@@ -27660,18 +32655,27 @@
}
private:
- StructureType sType = StructureType::eDisplayPresentInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Rect2D srcRect;
- Rect2D dstRect;
- Bool32 persistent;
+ using layout::DisplayPresentInfoKHR::sType;
};
static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct DisplayPropertiesKHR
{
+ DisplayPropertiesKHR()
+ {}
+
+ DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPropertiesKHR*>(this) = rhs;
+ }
+
+ DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayPropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
operator VkDisplayPropertiesKHR const&() const
{
return *reinterpret_cast<const VkDisplayPropertiesKHR*>( this );
@@ -27698,18 +32702,61 @@
return !operator==( rhs );
}
- DisplayKHR display;
+ public:
+ vk::DisplayKHR display;
const char* displayName;
- Extent2D physicalDimensions;
- Extent2D physicalResolution;
- SurfaceTransformFlagsKHR supportedTransforms;
- Bool32 planeReorderPossible;
- Bool32 persistentContent;
+ vk::Extent2D physicalDimensions;
+ vk::Extent2D physicalResolution;
+ vk::SurfaceTransformFlagsKHR supportedTransforms;
+ vk::Bool32 planeReorderPossible;
+ vk::Bool32 persistentContent;
};
static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplayProperties2KHR
+ namespace layout
{
+ struct DisplayProperties2KHR
+ {
+ protected:
+ DisplayProperties2KHR()
+ {}
+
+ DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayProperties2KHR*>(this) = rhs;
+ }
+
+ DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplayProperties2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplayProperties2KHR;
+ void* pNext = nullptr;
+ vk::DisplayPropertiesKHR displayProperties;
+ };
+ static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplayProperties2KHR : public layout::DisplayProperties2KHR
+ {
+ DisplayProperties2KHR()
+ : layout::DisplayProperties2KHR()
+ {}
+
+ DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs )
+ : layout::DisplayProperties2KHR( rhs )
+ {}
+
+ DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs )
+ {
+ layout::DisplayProperties2KHR::operator=(rhs);
+ return *this;
+ }
+
operator VkDisplayProperties2KHR const&() const
{
return *reinterpret_cast<const VkDisplayProperties2KHR*>( this );
@@ -27733,42 +32780,80 @@
}
private:
- StructureType sType = StructureType::eDisplayProperties2KHR;
-
- public:
- void* pNext = nullptr;
- DisplayPropertiesKHR displayProperties;
+ using layout::DisplayProperties2KHR::sType;
};
static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplayProperties2KHR>::value, "struct wrapper is not a standard layout!" );
- struct DisplaySurfaceCreateInfoKHR
+ namespace layout
{
- 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() )
- : flags( flags_ )
- , displayMode( displayMode_ )
- , planeIndex( planeIndex_ )
- , planeStackIndex( planeStackIndex_ )
- , transform( transform_ )
- , globalAlpha( globalAlpha_ )
- , alphaMode( alphaMode_ )
- , imageExtent( imageExtent_ )
+ struct DisplaySurfaceCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(),
+ vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(),
+ uint32_t planeIndex_ = 0,
+ uint32_t planeStackIndex_ = 0,
+ vk::SurfaceTransformFlagBitsKHR transform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+ float globalAlpha_ = 0,
+ vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
+ vk::Extent2D imageExtent_ = vk::Extent2D() )
+ : flags( flags_ )
+ , displayMode( displayMode_ )
+ , planeIndex( planeIndex_ )
+ , planeStackIndex( planeStackIndex_ )
+ , transform( transform_ )
+ , globalAlpha( globalAlpha_ )
+ , alphaMode( alphaMode_ )
+ , imageExtent( imageExtent_ )
+ {}
+
+ DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
+ }
+
+ DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::DisplaySurfaceCreateFlagsKHR flags;
+ vk::DisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+ vk::SurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+ vk::DisplayPlaneAlphaFlagBitsKHR alphaMode;
+ vk::Extent2D imageExtent;
+ };
+ static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DisplaySurfaceCreateInfoKHR : public layout::DisplaySurfaceCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(),
+ vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(),
+ uint32_t planeIndex_ = 0,
+ uint32_t planeStackIndex_ = 0,
+ vk::SurfaceTransformFlagBitsKHR transform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+ float globalAlpha_ = 0,
+ vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
+ vk::Extent2D imageExtent_ = vk::Extent2D() )
+ : layout::DisplaySurfaceCreateInfoKHR( flags_, displayMode_, planeIndex_, planeStackIndex_, transform_, globalAlpha_, alphaMode_, imageExtent_ )
{}
DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
- }
+ : layout::DisplaySurfaceCreateInfoKHR( rhs )
+ {}
DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
+ layout::DisplaySurfaceCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -27778,13 +32863,13 @@
return *this;
}
- DisplaySurfaceCreateInfoKHR & setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
+ DisplaySurfaceCreateInfoKHR & setFlags( vk::DisplaySurfaceCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
}
- DisplaySurfaceCreateInfoKHR & setDisplayMode( DisplayModeKHR displayMode_ )
+ DisplaySurfaceCreateInfoKHR & setDisplayMode( vk::DisplayModeKHR displayMode_ )
{
displayMode = displayMode_;
return *this;
@@ -27802,7 +32887,7 @@
return *this;
}
- DisplaySurfaceCreateInfoKHR & setTransform( SurfaceTransformFlagBitsKHR transform_ )
+ DisplaySurfaceCreateInfoKHR & setTransform( vk::SurfaceTransformFlagBitsKHR transform_ )
{
transform = transform_;
return *this;
@@ -27814,13 +32899,13 @@
return *this;
}
- DisplaySurfaceCreateInfoKHR & setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
+ DisplaySurfaceCreateInfoKHR & setAlphaMode( vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
{
alphaMode = alphaMode_;
return *this;
}
- DisplaySurfaceCreateInfoKHR & setImageExtent( Extent2D imageExtent_ )
+ DisplaySurfaceCreateInfoKHR & setImageExtent( vk::Extent2D imageExtent_ )
{
imageExtent = imageExtent_;
return *this;
@@ -27856,28 +32941,18 @@
}
private:
- StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- DisplaySurfaceCreateFlagsKHR flags;
- DisplayModeKHR displayMode;
- uint32_t planeIndex;
- uint32_t planeStackIndex;
- SurfaceTransformFlagBitsKHR transform;
- float globalAlpha;
- DisplayPlaneAlphaFlagBitsKHR alphaMode;
- Extent2D imageExtent;
+ using layout::DisplaySurfaceCreateInfoKHR::sType;
};
static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DisplaySurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct DrawIndexedIndirectCommand
{
- DrawIndexedIndirectCommand( uint32_t indexCount_ = 0,
- uint32_t instanceCount_ = 0,
- uint32_t firstIndex_ = 0,
- int32_t vertexOffset_ = 0,
- uint32_t firstInstance_ = 0 )
+ VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( uint32_t indexCount_ = 0,
+ uint32_t instanceCount_ = 0,
+ uint32_t firstIndex_ = 0,
+ int32_t vertexOffset_ = 0,
+ uint32_t firstInstance_ = 0 )
: indexCount( indexCount_ )
, instanceCount( instanceCount_ )
, firstIndex( firstIndex_ )
@@ -27887,12 +32962,12 @@
DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
+ *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this) = rhs;
}
DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
+ *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this) = rhs;
return *this;
}
@@ -27950,6 +33025,7 @@
return !operator==( rhs );
}
+ public:
uint32_t indexCount;
uint32_t instanceCount;
uint32_t firstIndex;
@@ -27957,13 +33033,14 @@
uint32_t firstInstance;
};
static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DrawIndexedIndirectCommand>::value, "struct wrapper is not a standard layout!" );
struct DrawIndirectCommand
{
- DrawIndirectCommand( uint32_t vertexCount_ = 0,
- uint32_t instanceCount_ = 0,
- uint32_t firstVertex_ = 0,
- uint32_t firstInstance_ = 0 )
+ VULKAN_HPP_CONSTEXPR DrawIndirectCommand( uint32_t vertexCount_ = 0,
+ uint32_t instanceCount_ = 0,
+ uint32_t firstVertex_ = 0,
+ uint32_t firstInstance_ = 0 )
: vertexCount( vertexCount_ )
, instanceCount( instanceCount_ )
, firstVertex( firstVertex_ )
@@ -27972,12 +33049,12 @@
DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
+ *reinterpret_cast<VkDrawIndirectCommand*>(this) = rhs;
}
DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
+ *reinterpret_cast<VkDrawIndirectCommand*>(this) = rhs;
return *this;
}
@@ -28028,29 +33105,31 @@
return !operator==( rhs );
}
+ public:
uint32_t vertexCount;
uint32_t instanceCount;
uint32_t firstVertex;
uint32_t firstInstance;
};
static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DrawIndirectCommand>::value, "struct wrapper is not a standard layout!" );
struct DrawMeshTasksIndirectCommandNV
{
- DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
- uint32_t firstTask_ = 0 )
+ VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = 0,
+ uint32_t firstTask_ = 0 )
: taskCount( taskCount_ )
, firstTask( firstTask_ )
{}
DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+ *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this) = rhs;
}
DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs )
{
- memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
+ *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this) = rhs;
return *this;
}
@@ -28087,13 +33166,29 @@
return !operator==( rhs );
}
+ public:
uint32_t taskCount;
uint32_t firstTask;
};
static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DrawMeshTasksIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
struct DrmFormatModifierPropertiesEXT
{
+ DrmFormatModifierPropertiesEXT()
+ {}
+
+ DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this) = rhs;
+ }
+
+ DrmFormatModifierPropertiesEXT& operator=( VkDrmFormatModifierPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
operator VkDrmFormatModifierPropertiesEXT const&() const
{
return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>( this );
@@ -28116,14 +33211,58 @@
return !operator==( rhs );
}
+ public:
uint64_t drmFormatModifier;
uint32_t drmFormatModifierPlaneCount;
- FormatFeatureFlags drmFormatModifierTilingFeatures;
+ vk::FormatFeatureFlags drmFormatModifierTilingFeatures;
};
static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct DrmFormatModifierPropertiesListEXT
+ namespace layout
{
+ struct DrmFormatModifierPropertiesListEXT
+ {
+ protected:
+ DrmFormatModifierPropertiesListEXT()
+ {}
+
+ DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs )
+ {
+ *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
+ }
+
+ DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs )
+ {
+ *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
+ void* pNext = nullptr;
+ uint32_t drmFormatModifierCount;
+ vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
+ };
+ static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct DrmFormatModifierPropertiesListEXT : public layout::DrmFormatModifierPropertiesListEXT
+ {
+ DrmFormatModifierPropertiesListEXT()
+ : layout::DrmFormatModifierPropertiesListEXT()
+ {}
+
+ DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs )
+ : layout::DrmFormatModifierPropertiesListEXT( rhs )
+ {}
+
+ DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs )
+ {
+ layout::DrmFormatModifierPropertiesListEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkDrmFormatModifierPropertiesListEXT const&() const
{
return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>( this );
@@ -28148,29 +33287,52 @@
}
private:
- StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t drmFormatModifierCount;
- DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;
+ using layout::DrmFormatModifierPropertiesListEXT::sType;
};
static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<DrmFormatModifierPropertiesListEXT>::value, "struct wrapper is not a standard layout!" );
- struct EventCreateInfo
+ namespace layout
{
- EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
- : flags( flags_ )
+ struct EventCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() )
+ : flags( flags_ )
+ {}
+
+ EventCreateInfo( VkEventCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
+ }
+
+ EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkEventCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eEventCreateInfo;
+ const void* pNext = nullptr;
+ vk::EventCreateFlags flags;
+ };
+ static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct EventCreateInfo : public layout::EventCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() )
+ : layout::EventCreateInfo( flags_ )
{}
EventCreateInfo( VkEventCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( EventCreateInfo ) );
- }
+ : layout::EventCreateInfo( rhs )
+ {}
EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( EventCreateInfo ) );
+ layout::EventCreateInfo::operator=(rhs);
return *this;
}
@@ -28180,7 +33342,7 @@
return *this;
}
- EventCreateInfo & setFlags( EventCreateFlags flags_ )
+ EventCreateInfo & setFlags( vk::EventCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -28209,28 +33371,52 @@
}
private:
- StructureType sType = StructureType::eEventCreateInfo;
-
- public:
- const void* pNext = nullptr;
- EventCreateFlags flags;
+ using layout::EventCreateInfo::sType;
};
static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<EventCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ExportFenceCreateInfo
+ namespace layout
{
- ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = ExternalFenceHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ struct ExportFenceCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExportFenceCreateInfo*>(this) = rhs;
+ }
+
+ ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExportFenceCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportFenceCreateInfo;
+ const void* pNext = nullptr;
+ vk::ExternalFenceHandleTypeFlags handleTypes;
+ };
+ static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportFenceCreateInfo : public layout::ExportFenceCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() )
+ : layout::ExportFenceCreateInfo( handleTypes_ )
{}
ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
- }
+ : layout::ExportFenceCreateInfo( rhs )
+ {}
ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
+ layout::ExportFenceCreateInfo::operator=(rhs);
return *this;
}
@@ -28240,7 +33426,7 @@
return *this;
}
- ExportFenceCreateInfo & setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ )
+ ExportFenceCreateInfo & setHandleTypes( vk::ExternalFenceHandleTypeFlags handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -28269,33 +33455,62 @@
}
private:
- StructureType sType = StructureType::eExportFenceCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalFenceHandleTypeFlags handleTypes;
+ using layout::ExportFenceCreateInfo::sType;
};
static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportFenceCreateInfo>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ExportFenceWin32HandleInfoKHR
+
+ namespace layout
{
- ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
- DWORD dwAccess_ = 0,
- LPCWSTR name_ = nullptr )
- : pAttributes( pAttributes_ )
- , dwAccess( dwAccess_ )
- , name( name_ )
+ struct ExportFenceWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0,
+ LPCWSTR name_ = nullptr )
+ : pAttributes( pAttributes_ )
+ , dwAccess( dwAccess_ )
+ , name( name_ )
+ {}
+
+ ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+ };
+ static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportFenceWin32HandleInfoKHR : public layout::ExportFenceWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0,
+ LPCWSTR name_ = nullptr )
+ : layout::ExportFenceWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
{}
ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
- }
+ : layout::ExportFenceWin32HandleInfoKHR( rhs )
+ {}
ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
+ layout::ExportFenceWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -28348,31 +33563,53 @@
}
private:
- StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- const SECURITY_ATTRIBUTES* pAttributes;
- DWORD dwAccess;
- LPCWSTR name;
+ using layout::ExportFenceWin32HandleInfoKHR::sType;
};
static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct ExportMemoryAllocateInfo
+ namespace layout
{
- ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ struct ExportMemoryAllocateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryAllocateInfo*>(this) = rhs;
+ }
+
+ ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryAllocateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportMemoryAllocateInfo;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlags handleTypes;
+ };
+ static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportMemoryAllocateInfo : public layout::ExportMemoryAllocateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+ : layout::ExportMemoryAllocateInfo( handleTypes_ )
{}
ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
- }
+ : layout::ExportMemoryAllocateInfo( rhs )
+ {}
ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
+ layout::ExportMemoryAllocateInfo::operator=(rhs);
return *this;
}
@@ -28382,7 +33619,7 @@
return *this;
}
- ExportMemoryAllocateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+ ExportMemoryAllocateInfo & setHandleTypes( vk::ExternalMemoryHandleTypeFlags handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -28411,28 +33648,52 @@
}
private:
- StructureType sType = StructureType::eExportMemoryAllocateInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlags handleTypes;
+ using layout::ExportMemoryAllocateInfo::sType;
};
static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportMemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ExportMemoryAllocateInfoNV
+ namespace layout
{
- ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : handleTypes( handleTypes_ )
+ struct ExportMemoryAllocateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
+ }
+
+ ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagsNV handleTypes;
+ };
+ static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportMemoryAllocateInfoNV : public layout::ExportMemoryAllocateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+ : layout::ExportMemoryAllocateInfoNV( handleTypes_ )
{}
ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
- }
+ : layout::ExportMemoryAllocateInfoNV( rhs )
+ {}
ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
+ layout::ExportMemoryAllocateInfoNV::operator=(rhs);
return *this;
}
@@ -28442,7 +33703,7 @@
return *this;
}
- ExportMemoryAllocateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ ExportMemoryAllocateInfoNV & setHandleTypes( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -28471,33 +33732,62 @@
}
private:
- StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagsNV handleTypes;
+ using layout::ExportMemoryAllocateInfoNV::sType;
};
static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ExportMemoryWin32HandleInfoKHR
+
+ namespace layout
{
- ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
- DWORD dwAccess_ = 0,
- LPCWSTR name_ = nullptr )
- : pAttributes( pAttributes_ )
- , dwAccess( dwAccess_ )
- , name( name_ )
+ struct ExportMemoryWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0,
+ LPCWSTR name_ = nullptr )
+ : pAttributes( pAttributes_ )
+ , dwAccess( dwAccess_ )
+ , name( name_ )
+ {}
+
+ ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+ };
+ static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportMemoryWin32HandleInfoKHR : public layout::ExportMemoryWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0,
+ LPCWSTR name_ = nullptr )
+ : layout::ExportMemoryWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
{}
ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
- }
+ : layout::ExportMemoryWin32HandleInfoKHR( rhs )
+ {}
ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
+ layout::ExportMemoryWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -28550,34 +33840,59 @@
}
private:
- StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- const SECURITY_ATTRIBUTES* pAttributes;
- DWORD dwAccess;
- LPCWSTR name;
+ using layout::ExportMemoryWin32HandleInfoKHR::sType;
};
static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ExportMemoryWin32HandleInfoNV
+
+ namespace layout
{
- ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
- DWORD dwAccess_ = 0 )
- : pAttributes( pAttributes_ )
- , dwAccess( dwAccess_ )
+ struct ExportMemoryWin32HandleInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0 )
+ : pAttributes( pAttributes_ )
+ , dwAccess( dwAccess_ )
+ {}
+
+ ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
+ }
+
+ ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
+ const void* pNext = nullptr;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ };
+ static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportMemoryWin32HandleInfoNV : public layout::ExportMemoryWin32HandleInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0 )
+ : layout::ExportMemoryWin32HandleInfoNV( pAttributes_, dwAccess_ )
{}
ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
- }
+ : layout::ExportMemoryWin32HandleInfoNV( rhs )
+ {}
ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
+ layout::ExportMemoryWin32HandleInfoNV::operator=(rhs);
return *this;
}
@@ -28623,30 +33938,53 @@
}
private:
- StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
-
- public:
- const void* pNext = nullptr;
- const SECURITY_ATTRIBUTES* pAttributes;
- DWORD dwAccess;
+ using layout::ExportMemoryWin32HandleInfoNV::sType;
};
static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct ExportSemaphoreCreateInfo
+ namespace layout
{
- ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = ExternalSemaphoreHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ struct ExportSemaphoreCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this) = rhs;
+ }
+
+ ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo;
+ const void* pNext = nullptr;
+ vk::ExternalSemaphoreHandleTypeFlags handleTypes;
+ };
+ static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportSemaphoreCreateInfo : public layout::ExportSemaphoreCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() )
+ : layout::ExportSemaphoreCreateInfo( handleTypes_ )
{}
ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
- }
+ : layout::ExportSemaphoreCreateInfo( rhs )
+ {}
ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
+ layout::ExportSemaphoreCreateInfo::operator=(rhs);
return *this;
}
@@ -28656,7 +33994,7 @@
return *this;
}
- ExportSemaphoreCreateInfo & setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ )
+ ExportSemaphoreCreateInfo & setHandleTypes( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -28685,33 +34023,62 @@
}
private:
- StructureType sType = StructureType::eExportSemaphoreCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalSemaphoreHandleTypeFlags handleTypes;
+ using layout::ExportSemaphoreCreateInfo::sType;
};
static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportSemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ExportSemaphoreWin32HandleInfoKHR
+
+ namespace layout
{
- ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
- DWORD dwAccess_ = 0,
- LPCWSTR name_ = nullptr )
- : pAttributes( pAttributes_ )
- , dwAccess( dwAccess_ )
- , name( name_ )
+ struct ExportSemaphoreWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0,
+ LPCWSTR name_ = nullptr )
+ : pAttributes( pAttributes_ )
+ , dwAccess( dwAccess_ )
+ , name( name_ )
+ {}
+
+ ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ const SECURITY_ATTRIBUTES* pAttributes;
+ DWORD dwAccess;
+ LPCWSTR name;
+ };
+ static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExportSemaphoreWin32HandleInfoKHR : public layout::ExportSemaphoreWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
+ DWORD dwAccess_ = 0,
+ LPCWSTR name_ = nullptr )
+ : layout::ExportSemaphoreWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ )
{}
ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
- }
+ : layout::ExportSemaphoreWin32HandleInfoKHR( rhs )
+ {}
ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
+ layout::ExportSemaphoreWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -28764,19 +34131,28 @@
}
private:
- StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- const SECURITY_ATTRIBUTES* pAttributes;
- DWORD dwAccess;
- LPCWSTR name;
+ using layout::ExportSemaphoreWin32HandleInfoKHR::sType;
};
static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct ExtensionProperties
{
+ ExtensionProperties()
+ {}
+
+ ExtensionProperties( VkExtensionProperties const & rhs )
+ {
+ *reinterpret_cast<VkExtensionProperties*>(this) = rhs;
+ }
+
+ ExtensionProperties& operator=( VkExtensionProperties const & rhs )
+ {
+ *reinterpret_cast<VkExtensionProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkExtensionProperties const&() const
{
return *reinterpret_cast<const VkExtensionProperties*>( this );
@@ -28798,13 +34174,29 @@
return !operator==( rhs );
}
+ public:
char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
uint32_t specVersion;
};
static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExtensionProperties>::value, "struct wrapper is not a standard layout!" );
struct ExternalMemoryProperties
{
+ ExternalMemoryProperties()
+ {}
+
+ ExternalMemoryProperties( VkExternalMemoryProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryProperties*>(this) = rhs;
+ }
+
+ ExternalMemoryProperties& operator=( VkExternalMemoryProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkExternalMemoryProperties const&() const
{
return *reinterpret_cast<const VkExternalMemoryProperties*>( this );
@@ -28827,14 +34219,57 @@
return !operator==( rhs );
}
- ExternalMemoryFeatureFlags externalMemoryFeatures;
- ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
- ExternalMemoryHandleTypeFlags compatibleHandleTypes;
+ public:
+ vk::ExternalMemoryFeatureFlags externalMemoryFeatures;
+ vk::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
+ vk::ExternalMemoryHandleTypeFlags compatibleHandleTypes;
};
static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalMemoryProperties>::value, "struct wrapper is not a standard layout!" );
- struct ExternalBufferProperties
+ namespace layout
{
+ struct ExternalBufferProperties
+ {
+ protected:
+ ExternalBufferProperties()
+ {}
+
+ ExternalBufferProperties( VkExternalBufferProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalBufferProperties*>(this) = rhs;
+ }
+
+ ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalBufferProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalBufferProperties;
+ void* pNext = nullptr;
+ vk::ExternalMemoryProperties externalMemoryProperties;
+ };
+ static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalBufferProperties : public layout::ExternalBufferProperties
+ {
+ ExternalBufferProperties()
+ : layout::ExternalBufferProperties()
+ {}
+
+ ExternalBufferProperties( VkExternalBufferProperties const & rhs )
+ : layout::ExternalBufferProperties( rhs )
+ {}
+
+ ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs )
+ {
+ layout::ExternalBufferProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkExternalBufferProperties const&() const
{
return *reinterpret_cast<const VkExternalBufferProperties*>( this );
@@ -28858,16 +34293,56 @@
}
private:
- StructureType sType = StructureType::eExternalBufferProperties;
-
- public:
- void* pNext = nullptr;
- ExternalMemoryProperties externalMemoryProperties;
+ using layout::ExternalBufferProperties::sType;
};
static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalBufferProperties>::value, "struct wrapper is not a standard layout!" );
- struct ExternalFenceProperties
+ namespace layout
{
+ struct ExternalFenceProperties
+ {
+ protected:
+ ExternalFenceProperties()
+ {}
+
+ ExternalFenceProperties( VkExternalFenceProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalFenceProperties*>(this) = rhs;
+ }
+
+ ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalFenceProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalFenceProperties;
+ void* pNext = nullptr;
+ vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+ vk::ExternalFenceHandleTypeFlags compatibleHandleTypes;
+ vk::ExternalFenceFeatureFlags externalFenceFeatures;
+ };
+ static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalFenceProperties : public layout::ExternalFenceProperties
+ {
+ ExternalFenceProperties()
+ : layout::ExternalFenceProperties()
+ {}
+
+ ExternalFenceProperties( VkExternalFenceProperties const & rhs )
+ : layout::ExternalFenceProperties( rhs )
+ {}
+
+ ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs )
+ {
+ layout::ExternalFenceProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkExternalFenceProperties const&() const
{
return *reinterpret_cast<const VkExternalFenceProperties*>( this );
@@ -28893,31 +34368,54 @@
}
private:
- StructureType sType = StructureType::eExternalFenceProperties;
-
- public:
- void* pNext = nullptr;
- ExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
- ExternalFenceHandleTypeFlags compatibleHandleTypes;
- ExternalFenceFeatureFlags externalFenceFeatures;
+ using layout::ExternalFenceProperties::sType;
};
static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalFenceProperties>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct ExternalFormatANDROID
+
+ namespace layout
{
- ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
- : externalFormat( externalFormat_ )
+ struct ExternalFormatANDROID
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
+ : externalFormat( externalFormat_ )
+ {}
+
+ ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
+ {
+ *reinterpret_cast<VkExternalFormatANDROID*>(this) = rhs;
+ }
+
+ ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
+ {
+ *reinterpret_cast<VkExternalFormatANDROID*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalFormatANDROID;
+ void* pNext = nullptr;
+ uint64_t externalFormat;
+ };
+ static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalFormatANDROID : public layout::ExternalFormatANDROID
+ {
+ VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
+ : layout::ExternalFormatANDROID( externalFormat_ )
{}
ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
- }
+ : layout::ExternalFormatANDROID( rhs )
+ {}
ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
+ layout::ExternalFormatANDROID::operator=(rhs);
return *this;
}
@@ -28956,17 +34454,55 @@
}
private:
- StructureType sType = StructureType::eExternalFormatANDROID;
-
- public:
- void* pNext = nullptr;
- uint64_t externalFormat;
+ using layout::ExternalFormatANDROID::sType;
};
static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalFormatANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- struct ExternalImageFormatProperties
+ namespace layout
{
+ struct ExternalImageFormatProperties
+ {
+ protected:
+ ExternalImageFormatProperties()
+ {}
+
+ ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalImageFormatProperties*>(this) = rhs;
+ }
+
+ ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalImageFormatProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalImageFormatProperties;
+ void* pNext = nullptr;
+ vk::ExternalMemoryProperties externalMemoryProperties;
+ };
+ static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalImageFormatProperties : public layout::ExternalImageFormatProperties
+ {
+ ExternalImageFormatProperties()
+ : layout::ExternalImageFormatProperties()
+ {}
+
+ ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs )
+ : layout::ExternalImageFormatProperties( rhs )
+ {}
+
+ ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs )
+ {
+ layout::ExternalImageFormatProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkExternalImageFormatProperties const&() const
{
return *reinterpret_cast<const VkExternalImageFormatProperties*>( this );
@@ -28990,16 +34526,27 @@
}
private:
- StructureType sType = StructureType::eExternalImageFormatProperties;
-
- public:
- void* pNext = nullptr;
- ExternalMemoryProperties externalMemoryProperties;
+ using layout::ExternalImageFormatProperties::sType;
};
static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
struct ImageFormatProperties
{
+ ImageFormatProperties()
+ {}
+
+ ImageFormatProperties( VkImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkImageFormatProperties*>(this) = rhs;
+ }
+
+ ImageFormatProperties& operator=( VkImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkImageFormatProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkImageFormatProperties const&() const
{
return *reinterpret_cast<const VkImageFormatProperties*>( this );
@@ -29024,16 +34571,32 @@
return !operator==( rhs );
}
- Extent3D maxExtent;
+ public:
+ vk::Extent3D maxExtent;
uint32_t maxMipLevels;
uint32_t maxArrayLayers;
- SampleCountFlags sampleCounts;
- DeviceSize maxResourceSize;
+ vk::SampleCountFlags sampleCounts;
+ vk::DeviceSize maxResourceSize;
};
static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
struct ExternalImageFormatPropertiesNV
{
+ ExternalImageFormatPropertiesNV()
+ {}
+
+ ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this) = rhs;
+ }
+
+ ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
operator VkExternalImageFormatPropertiesNV const&() const
{
return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>( this );
@@ -29057,27 +34620,56 @@
return !operator==( rhs );
}
- ImageFormatProperties imageFormatProperties;
- ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
- ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
- ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
+ public:
+ vk::ImageFormatProperties imageFormatProperties;
+ vk::ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
+ vk::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
+ vk::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
};
static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalImageFormatPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct ExternalMemoryBufferCreateInfo
+ namespace layout
{
- ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ struct ExternalMemoryBufferCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
+ }
+
+ ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlags handleTypes;
+ };
+ static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalMemoryBufferCreateInfo : public layout::ExternalMemoryBufferCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+ : layout::ExternalMemoryBufferCreateInfo( handleTypes_ )
{}
ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
- }
+ : layout::ExternalMemoryBufferCreateInfo( rhs )
+ {}
ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
+ layout::ExternalMemoryBufferCreateInfo::operator=(rhs);
return *this;
}
@@ -29087,7 +34679,7 @@
return *this;
}
- ExternalMemoryBufferCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+ ExternalMemoryBufferCreateInfo & setHandleTypes( vk::ExternalMemoryHandleTypeFlags handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -29116,28 +34708,52 @@
}
private:
- StructureType sType = StructureType::eExternalMemoryBufferCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlags handleTypes;
+ using layout::ExternalMemoryBufferCreateInfo::sType;
};
static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalMemoryBufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ExternalMemoryImageCreateInfo
+ namespace layout
{
- ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = ExternalMemoryHandleTypeFlags() )
- : handleTypes( handleTypes_ )
+ struct ExternalMemoryImageCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this) = rhs;
+ }
+
+ ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlags handleTypes;
+ };
+ static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalMemoryImageCreateInfo : public layout::ExternalMemoryImageCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() )
+ : layout::ExternalMemoryImageCreateInfo( handleTypes_ )
{}
ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
- }
+ : layout::ExternalMemoryImageCreateInfo( rhs )
+ {}
ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
+ layout::ExternalMemoryImageCreateInfo::operator=(rhs);
return *this;
}
@@ -29147,7 +34763,7 @@
return *this;
}
- ExternalMemoryImageCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ )
+ ExternalMemoryImageCreateInfo & setHandleTypes( vk::ExternalMemoryHandleTypeFlags handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -29176,28 +34792,52 @@
}
private:
- StructureType sType = StructureType::eExternalMemoryImageCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlags handleTypes;
+ using layout::ExternalMemoryImageCreateInfo::sType;
};
static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ExternalMemoryImageCreateInfoNV
+ namespace layout
{
- ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : handleTypes( handleTypes_ )
+ struct ExternalMemoryImageCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+ : handleTypes( handleTypes_ )
+ {}
+
+ ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
+ }
+
+ ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagsNV handleTypes;
+ };
+ static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalMemoryImageCreateInfoNV : public layout::ExternalMemoryImageCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() )
+ : layout::ExternalMemoryImageCreateInfoNV( handleTypes_ )
{}
ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
- }
+ : layout::ExternalMemoryImageCreateInfoNV( rhs )
+ {}
ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
+ layout::ExternalMemoryImageCreateInfoNV::operator=(rhs);
return *this;
}
@@ -29207,7 +34847,7 @@
return *this;
}
- ExternalMemoryImageCreateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
+ ExternalMemoryImageCreateInfoNV & setHandleTypes( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ )
{
handleTypes = handleTypes_;
return *this;
@@ -29236,16 +34876,56 @@
}
private:
- StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagsNV handleTypes;
+ using layout::ExternalMemoryImageCreateInfoNV::sType;
};
static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct ExternalSemaphoreProperties
+ namespace layout
{
+ struct ExternalSemaphoreProperties
+ {
+ protected:
+ ExternalSemaphoreProperties()
+ {}
+
+ ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalSemaphoreProperties*>(this) = rhs;
+ }
+
+ ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs )
+ {
+ *reinterpret_cast<VkExternalSemaphoreProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eExternalSemaphoreProperties;
+ void* pNext = nullptr;
+ vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+ vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+ vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+ };
+ static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ExternalSemaphoreProperties : public layout::ExternalSemaphoreProperties
+ {
+ ExternalSemaphoreProperties()
+ : layout::ExternalSemaphoreProperties()
+ {}
+
+ ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs )
+ : layout::ExternalSemaphoreProperties( rhs )
+ {}
+
+ ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs )
+ {
+ layout::ExternalSemaphoreProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkExternalSemaphoreProperties const&() const
{
return *reinterpret_cast<const VkExternalSemaphoreProperties*>( this );
@@ -29271,30 +34951,52 @@
}
private:
- StructureType sType = StructureType::eExternalSemaphoreProperties;
-
- public:
- void* pNext = nullptr;
- ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
- ExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
- ExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+ using layout::ExternalSemaphoreProperties::sType;
};
static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ExternalSemaphoreProperties>::value, "struct wrapper is not a standard layout!" );
- struct FenceCreateInfo
+ namespace layout
{
- FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
- : flags( flags_ )
+ struct FenceCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() )
+ : flags( flags_ )
+ {}
+
+ FenceCreateInfo( VkFenceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkFenceCreateInfo*>(this) = rhs;
+ }
+
+ FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkFenceCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFenceCreateInfo;
+ const void* pNext = nullptr;
+ vk::FenceCreateFlags flags;
+ };
+ static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FenceCreateInfo : public layout::FenceCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() )
+ : layout::FenceCreateInfo( flags_ )
{}
FenceCreateInfo( VkFenceCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
- }
+ : layout::FenceCreateInfo( rhs )
+ {}
FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
+ layout::FenceCreateInfo::operator=(rhs);
return *this;
}
@@ -29304,7 +35006,7 @@
return *this;
}
- FenceCreateInfo & setFlags( FenceCreateFlags flags_ )
+ FenceCreateInfo & setFlags( vk::FenceCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -29333,30 +35035,56 @@
}
private:
- StructureType sType = StructureType::eFenceCreateInfo;
-
- public:
- const void* pNext = nullptr;
- FenceCreateFlags flags;
+ using layout::FenceCreateInfo::sType;
};
static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FenceCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct FenceGetFdInfoKHR
+ namespace layout
{
- FenceGetFdInfoKHR( Fence fence_ = Fence(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
- : fence( fence_ )
- , handleType( handleType_ )
+ struct FenceGetFdInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : fence( fence_ )
+ , handleType( handleType_ )
+ {}
+
+ FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFenceGetFdInfoKHR*>(this) = rhs;
+ }
+
+ FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFenceGetFdInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFenceGetFdInfoKHR;
+ const void* pNext = nullptr;
+ vk::Fence fence;
+ vk::ExternalFenceHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FenceGetFdInfoKHR : public layout::FenceGetFdInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : layout::FenceGetFdInfoKHR( fence_, handleType_ )
{}
FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
- }
+ : layout::FenceGetFdInfoKHR( rhs )
+ {}
FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
+ layout::FenceGetFdInfoKHR::operator=(rhs);
return *this;
}
@@ -29366,13 +35094,13 @@
return *this;
}
- FenceGetFdInfoKHR & setFence( Fence fence_ )
+ FenceGetFdInfoKHR & setFence( vk::Fence fence_ )
{
fence = fence_;
return *this;
}
- FenceGetFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ FenceGetFdInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -29402,32 +35130,58 @@
}
private:
- StructureType sType = StructureType::eFenceGetFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- ExternalFenceHandleTypeFlagBits handleType;
+ using layout::FenceGetFdInfoKHR::sType;
};
static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FenceGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct FenceGetWin32HandleInfoKHR
+
+ namespace layout
{
- FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
- : fence( fence_ )
- , handleType( handleType_ )
+ struct FenceGetWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : fence( fence_ )
+ , handleType( handleType_ )
+ {}
+
+ FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ vk::Fence fence;
+ vk::ExternalFenceHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FenceGetWin32HandleInfoKHR : public layout::FenceGetWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : layout::FenceGetWin32HandleInfoKHR( fence_, handleType_ )
{}
FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
- }
+ : layout::FenceGetWin32HandleInfoKHR( rhs )
+ {}
FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
+ layout::FenceGetWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -29437,13 +35191,13 @@
return *this;
}
- FenceGetWin32HandleInfoKHR & setFence( Fence fence_ )
+ FenceGetWin32HandleInfoKHR & setFence( vk::Fence fence_ )
{
fence = fence_;
return *this;
}
- FenceGetWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ FenceGetWin32HandleInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -29473,18 +35227,56 @@
}
private:
- StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- ExternalFenceHandleTypeFlagBits handleType;
+ using layout::FenceGetWin32HandleInfoKHR::sType;
};
static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FenceGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct FilterCubicImageViewImageFormatPropertiesEXT
+ namespace layout
{
+ struct FilterCubicImageViewImageFormatPropertiesEXT
+ {
+ protected:
+ FilterCubicImageViewImageFormatPropertiesEXT()
+ {}
+
+ FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this) = rhs;
+ }
+
+ FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 filterCubic;
+ vk::Bool32 filterCubicMinmax;
+ };
+ static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FilterCubicImageViewImageFormatPropertiesEXT : public layout::FilterCubicImageViewImageFormatPropertiesEXT
+ {
+ FilterCubicImageViewImageFormatPropertiesEXT()
+ : layout::FilterCubicImageViewImageFormatPropertiesEXT()
+ {}
+
+ FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs )
+ : layout::FilterCubicImageViewImageFormatPropertiesEXT( rhs )
+ {}
+
+ FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs )
+ {
+ layout::FilterCubicImageViewImageFormatPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkFilterCubicImageViewImageFormatPropertiesEXT const&() const
{
return *reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>( this );
@@ -29509,17 +35301,27 @@
}
private:
- StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 filterCubic;
- Bool32 filterCubicMinmax;
+ using layout::FilterCubicImageViewImageFormatPropertiesEXT::sType;
};
static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FilterCubicImageViewImageFormatPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
struct FormatProperties
{
+ FormatProperties()
+ {}
+
+ FormatProperties( VkFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkFormatProperties*>(this) = rhs;
+ }
+
+ FormatProperties& operator=( VkFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkFormatProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkFormatProperties const&() const
{
return *reinterpret_cast<const VkFormatProperties*>( this );
@@ -29542,14 +35344,57 @@
return !operator==( rhs );
}
- FormatFeatureFlags linearTilingFeatures;
- FormatFeatureFlags optimalTilingFeatures;
- FormatFeatureFlags bufferFeatures;
+ public:
+ vk::FormatFeatureFlags linearTilingFeatures;
+ vk::FormatFeatureFlags optimalTilingFeatures;
+ vk::FormatFeatureFlags bufferFeatures;
};
static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FormatProperties>::value, "struct wrapper is not a standard layout!" );
- struct FormatProperties2
+ namespace layout
{
+ struct FormatProperties2
+ {
+ protected:
+ FormatProperties2()
+ {}
+
+ FormatProperties2( VkFormatProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
+ }
+
+ FormatProperties2& operator=( VkFormatProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFormatProperties2;
+ void* pNext = nullptr;
+ vk::FormatProperties formatProperties;
+ };
+ static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FormatProperties2 : public layout::FormatProperties2
+ {
+ FormatProperties2()
+ : layout::FormatProperties2()
+ {}
+
+ FormatProperties2( VkFormatProperties2 const & rhs )
+ : layout::FormatProperties2( rhs )
+ {}
+
+ FormatProperties2& operator=( VkFormatProperties2 const & rhs )
+ {
+ layout::FormatProperties2::operator=(rhs);
+ return *this;
+ }
+
operator VkFormatProperties2 const&() const
{
return *reinterpret_cast<const VkFormatProperties2*>( this );
@@ -29573,40 +35418,321 @@
}
private:
- StructureType sType = StructureType::eFormatProperties2;
-
- public:
- void* pNext = nullptr;
- FormatProperties formatProperties;
+ using layout::FormatProperties2::sType;
};
static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FormatProperties2>::value, "struct wrapper is not a standard layout!" );
- struct FramebufferCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , renderPass( renderPass_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , width( width_ )
- , height( height_ )
- , layers( layers_ )
+ struct FramebufferAttachmentImageInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ uint32_t width_ = 0,
+ uint32_t height_ = 0,
+ uint32_t layerCount_ = 0,
+ uint32_t viewFormatCount_ = 0,
+ const vk::Format* pViewFormats_ = nullptr )
+ : flags( flags_ )
+ , usage( usage_ )
+ , width( width_ )
+ , height( height_ )
+ , layerCount( layerCount_ )
+ , viewFormatCount( viewFormatCount_ )
+ , pViewFormats( pViewFormats_ )
+ {}
+
+ FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
+ }
+
+ FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR;
+ const void* pNext = nullptr;
+ vk::ImageCreateFlags flags;
+ vk::ImageUsageFlags usage;
+ uint32_t width;
+ uint32_t height;
+ uint32_t layerCount;
+ uint32_t viewFormatCount;
+ const vk::Format* pViewFormats;
+ };
+ static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FramebufferAttachmentImageInfoKHR : public layout::FramebufferAttachmentImageInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ uint32_t width_ = 0,
+ uint32_t height_ = 0,
+ uint32_t layerCount_ = 0,
+ uint32_t viewFormatCount_ = 0,
+ const vk::Format* pViewFormats_ = nullptr )
+ : layout::FramebufferAttachmentImageInfoKHR( flags_, usage_, width_, height_, layerCount_, viewFormatCount_, pViewFormats_ )
+ {}
+
+ FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs )
+ : layout::FramebufferAttachmentImageInfoKHR( rhs )
+ {}
+
+ FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs )
+ {
+ layout::FramebufferAttachmentImageInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setFlags( vk::ImageCreateFlags flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setUsage( vk::ImageUsageFlags usage_ )
+ {
+ usage = usage_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setWidth( uint32_t width_ )
+ {
+ width = width_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setHeight( uint32_t height_ )
+ {
+ height = height_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setLayerCount( uint32_t layerCount_ )
+ {
+ layerCount = layerCount_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setViewFormatCount( uint32_t viewFormatCount_ )
+ {
+ viewFormatCount = viewFormatCount_;
+ return *this;
+ }
+
+ FramebufferAttachmentImageInfoKHR & setPViewFormats( const vk::Format* pViewFormats_ )
+ {
+ pViewFormats = pViewFormats_;
+ return *this;
+ }
+
+ operator VkFramebufferAttachmentImageInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkFramebufferAttachmentImageInfoKHR*>( this );
+ }
+
+ operator VkFramebufferAttachmentImageInfoKHR &()
+ {
+ return *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>( this );
+ }
+
+ bool operator==( FramebufferAttachmentImageInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( usage == rhs.usage )
+ && ( width == rhs.width )
+ && ( height == rhs.height )
+ && ( layerCount == rhs.layerCount )
+ && ( viewFormatCount == rhs.viewFormatCount )
+ && ( pViewFormats == rhs.pViewFormats );
+ }
+
+ bool operator!=( FramebufferAttachmentImageInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::FramebufferAttachmentImageInfoKHR::sType;
+ };
+ static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FramebufferAttachmentImageInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct FramebufferAttachmentsCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
+ const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr )
+ : attachmentImageInfoCount( attachmentImageInfoCount_ )
+ , pAttachmentImageInfos( pAttachmentImageInfos_ )
+ {}
+
+ FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
+ }
+
+ FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t attachmentImageInfoCount;
+ const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
+ };
+ static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FramebufferAttachmentsCreateInfoKHR : public layout::FramebufferAttachmentsCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0,
+ const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr )
+ : layout::FramebufferAttachmentsCreateInfoKHR( attachmentImageInfoCount_, pAttachmentImageInfos_ )
+ {}
+
+ FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
+ : layout::FramebufferAttachmentsCreateInfoKHR( rhs )
+ {}
+
+ FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs )
+ {
+ layout::FramebufferAttachmentsCreateInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ FramebufferAttachmentsCreateInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ FramebufferAttachmentsCreateInfoKHR & setAttachmentImageInfoCount( uint32_t attachmentImageInfoCount_ )
+ {
+ attachmentImageInfoCount = attachmentImageInfoCount_;
+ return *this;
+ }
+
+ FramebufferAttachmentsCreateInfoKHR & setPAttachmentImageInfos( const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ )
+ {
+ pAttachmentImageInfos = pAttachmentImageInfos_;
+ return *this;
+ }
+
+ operator VkFramebufferAttachmentsCreateInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkFramebufferAttachmentsCreateInfoKHR*>( this );
+ }
+
+ operator VkFramebufferAttachmentsCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>( this );
+ }
+
+ bool operator==( FramebufferAttachmentsCreateInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( attachmentImageInfoCount == rhs.attachmentImageInfoCount )
+ && ( pAttachmentImageInfos == rhs.pAttachmentImageInfos );
+ }
+
+ bool operator!=( FramebufferAttachmentsCreateInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::FramebufferAttachmentsCreateInfoKHR::sType;
+ };
+ static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FramebufferAttachmentsCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct FramebufferCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(),
+ vk::RenderPass renderPass_ = vk::RenderPass(),
+ uint32_t attachmentCount_ = 0,
+ const vk::ImageView* pAttachments_ = nullptr,
+ uint32_t width_ = 0,
+ uint32_t height_ = 0,
+ uint32_t layers_ = 0 )
+ : flags( flags_ )
+ , renderPass( renderPass_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , width( width_ )
+ , height( height_ )
+ , layers( layers_ )
+ {}
+
+ FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferCreateInfo*>(this) = rhs;
+ }
+
+ FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFramebufferCreateInfo;
+ const void* pNext = nullptr;
+ vk::FramebufferCreateFlags flags;
+ vk::RenderPass renderPass;
+ uint32_t attachmentCount;
+ const vk::ImageView* pAttachments;
+ uint32_t width;
+ uint32_t height;
+ uint32_t layers;
+ };
+ static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FramebufferCreateInfo : public layout::FramebufferCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(),
+ vk::RenderPass renderPass_ = vk::RenderPass(),
+ uint32_t attachmentCount_ = 0,
+ const vk::ImageView* pAttachments_ = nullptr,
+ uint32_t width_ = 0,
+ uint32_t height_ = 0,
+ uint32_t layers_ = 0 )
+ : layout::FramebufferCreateInfo( flags_, renderPass_, attachmentCount_, pAttachments_, width_, height_, layers_ )
{}
FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
- }
+ : layout::FramebufferCreateInfo( rhs )
+ {}
FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
+ layout::FramebufferCreateInfo::operator=(rhs);
return *this;
}
@@ -29616,13 +35742,13 @@
return *this;
}
- FramebufferCreateInfo & setFlags( FramebufferCreateFlags flags_ )
+ FramebufferCreateInfo & setFlags( vk::FramebufferCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- FramebufferCreateInfo & setRenderPass( RenderPass renderPass_ )
+ FramebufferCreateInfo & setRenderPass( vk::RenderPass renderPass_ )
{
renderPass = renderPass_;
return *this;
@@ -29634,7 +35760,7 @@
return *this;
}
- FramebufferCreateInfo & setPAttachments( const ImageView* pAttachments_ )
+ FramebufferCreateInfo & setPAttachments( const vk::ImageView* pAttachments_ )
{
pAttachments = pAttachments_;
return *this;
@@ -29687,22 +35813,57 @@
}
private:
- StructureType sType = StructureType::eFramebufferCreateInfo;
-
- public:
- const void* pNext = nullptr;
- FramebufferCreateFlags flags;
- RenderPass renderPass;
- uint32_t attachmentCount;
- const ImageView* pAttachments;
- uint32_t width;
- uint32_t height;
- uint32_t layers;
+ using layout::FramebufferCreateInfo::sType;
};
static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FramebufferCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct FramebufferMixedSamplesCombinationNV
+ namespace layout
{
+ struct FramebufferMixedSamplesCombinationNV
+ {
+ protected:
+ FramebufferMixedSamplesCombinationNV()
+ {}
+
+ FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
+ }
+
+ FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs )
+ {
+ *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV;
+ void* pNext = nullptr;
+ vk::CoverageReductionModeNV coverageReductionMode;
+ vk::SampleCountFlagBits rasterizationSamples;
+ vk::SampleCountFlags depthStencilSamples;
+ vk::SampleCountFlags colorSamples;
+ };
+ static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct FramebufferMixedSamplesCombinationNV : public layout::FramebufferMixedSamplesCombinationNV
+ {
+ FramebufferMixedSamplesCombinationNV()
+ : layout::FramebufferMixedSamplesCombinationNV()
+ {}
+
+ FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs )
+ : layout::FramebufferMixedSamplesCombinationNV( rhs )
+ {}
+
+ FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs )
+ {
+ layout::FramebufferMixedSamplesCombinationNV::operator=(rhs);
+ return *this;
+ }
+
operator VkFramebufferMixedSamplesCombinationNV const&() const
{
return *reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>( this );
@@ -29729,22 +35890,16 @@
}
private:
- StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV;
-
- public:
- void* pNext = nullptr;
- CoverageReductionModeNV coverageReductionMode;
- SampleCountFlagBits rasterizationSamples;
- SampleCountFlags depthStencilSamples;
- SampleCountFlags colorSamples;
+ using layout::FramebufferMixedSamplesCombinationNV::sType;
};
static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<FramebufferMixedSamplesCombinationNV>::value, "struct wrapper is not a standard layout!" );
struct VertexInputBindingDescription
{
- VertexInputBindingDescription( uint32_t binding_ = 0,
- uint32_t stride_ = 0,
- VertexInputRate inputRate_ = VertexInputRate::eVertex )
+ VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( uint32_t binding_ = 0,
+ uint32_t stride_ = 0,
+ vk::VertexInputRate inputRate_ = vk::VertexInputRate::eVertex )
: binding( binding_ )
, stride( stride_ )
, inputRate( inputRate_ )
@@ -29752,12 +35907,12 @@
VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
+ *reinterpret_cast<VkVertexInputBindingDescription*>(this) = rhs;
}
VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
+ *reinterpret_cast<VkVertexInputBindingDescription*>(this) = rhs;
return *this;
}
@@ -29773,7 +35928,7 @@
return *this;
}
- VertexInputBindingDescription & setInputRate( VertexInputRate inputRate_ )
+ VertexInputBindingDescription & setInputRate( vk::VertexInputRate inputRate_ )
{
inputRate = inputRate_;
return *this;
@@ -29801,18 +35956,20 @@
return !operator==( rhs );
}
+ public:
uint32_t binding;
uint32_t stride;
- VertexInputRate inputRate;
+ vk::VertexInputRate inputRate;
};
static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<VertexInputBindingDescription>::value, "struct wrapper is not a standard layout!" );
struct VertexInputAttributeDescription
{
- VertexInputAttributeDescription( uint32_t location_ = 0,
- uint32_t binding_ = 0,
- Format format_ = Format::eUndefined,
- uint32_t offset_ = 0 )
+ VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( uint32_t location_ = 0,
+ uint32_t binding_ = 0,
+ vk::Format format_ = vk::Format::eUndefined,
+ uint32_t offset_ = 0 )
: location( location_ )
, binding( binding_ )
, format( format_ )
@@ -29821,12 +35978,12 @@
VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
+ *reinterpret_cast<VkVertexInputAttributeDescription*>(this) = rhs;
}
VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
+ *reinterpret_cast<VkVertexInputAttributeDescription*>(this) = rhs;
return *this;
}
@@ -29842,7 +35999,7 @@
return *this;
}
- VertexInputAttributeDescription & setFormat( Format format_ )
+ VertexInputAttributeDescription & setFormat( vk::Format format_ )
{
format = format_;
return *this;
@@ -29877,35 +36034,72 @@
return !operator==( rhs );
}
+ public:
uint32_t location;
uint32_t binding;
- Format format;
+ vk::Format format;
uint32_t offset;
};
static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<VertexInputAttributeDescription>::value, "struct wrapper is not a standard layout!" );
- struct PipelineVertexInputStateCreateInfo
+ namespace layout
{
- PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(),
- uint32_t vertexBindingDescriptionCount_ = 0,
- const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
- uint32_t vertexAttributeDescriptionCount_ = 0,
- const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
- : flags( flags_ )
- , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
- , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
- , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
- , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
+ struct PipelineVertexInputStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(),
+ uint32_t vertexBindingDescriptionCount_ = 0,
+ const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
+ uint32_t vertexAttributeDescriptionCount_ = 0,
+ const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
+ : flags( flags_ )
+ , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
+ , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
+ , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
+ , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
+ {}
+
+ PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineVertexInputStateCreateFlags flags;
+ uint32_t vertexBindingDescriptionCount;
+ const vk::VertexInputBindingDescription* pVertexBindingDescriptions;
+ uint32_t vertexAttributeDescriptionCount;
+ const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions;
+ };
+ static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineVertexInputStateCreateInfo : public layout::PipelineVertexInputStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(),
+ uint32_t vertexBindingDescriptionCount_ = 0,
+ const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
+ uint32_t vertexAttributeDescriptionCount_ = 0,
+ const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
+ : layout::PipelineVertexInputStateCreateInfo( flags_, vertexBindingDescriptionCount_, pVertexBindingDescriptions_, vertexAttributeDescriptionCount_, pVertexAttributeDescriptions_ )
{}
PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
- }
+ : layout::PipelineVertexInputStateCreateInfo( rhs )
+ {}
PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
+ layout::PipelineVertexInputStateCreateInfo::operator=(rhs);
return *this;
}
@@ -29915,7 +36109,7 @@
return *this;
}
- PipelineVertexInputStateCreateInfo & setFlags( PipelineVertexInputStateCreateFlags flags_ )
+ PipelineVertexInputStateCreateInfo & setFlags( vk::PipelineVertexInputStateCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -29927,7 +36121,7 @@
return *this;
}
- PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ )
+ PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions( const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ )
{
pVertexBindingDescriptions = pVertexBindingDescriptions_;
return *this;
@@ -29939,7 +36133,7 @@
return *this;
}
- PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
+ PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions( const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
{
pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
return *this;
@@ -29972,36 +36166,60 @@
}
private:
- StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineVertexInputStateCreateFlags flags;
- uint32_t vertexBindingDescriptionCount;
- const VertexInputBindingDescription* pVertexBindingDescriptions;
- uint32_t vertexAttributeDescriptionCount;
- const VertexInputAttributeDescription* pVertexAttributeDescriptions;
+ using layout::PipelineVertexInputStateCreateInfo::sType;
};
static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineVertexInputStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineInputAssemblyStateCreateInfo
+ namespace layout
{
- PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(),
- PrimitiveTopology topology_ = PrimitiveTopology::ePointList,
- Bool32 primitiveRestartEnable_ = 0 )
- : flags( flags_ )
- , topology( topology_ )
- , primitiveRestartEnable( primitiveRestartEnable_ )
+ struct PipelineInputAssemblyStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(),
+ vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList,
+ vk::Bool32 primitiveRestartEnable_ = 0 )
+ : flags( flags_ )
+ , topology( topology_ )
+ , primitiveRestartEnable( primitiveRestartEnable_ )
+ {}
+
+ PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineInputAssemblyStateCreateFlags flags;
+ vk::PrimitiveTopology topology;
+ vk::Bool32 primitiveRestartEnable;
+ };
+ static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineInputAssemblyStateCreateInfo : public layout::PipelineInputAssemblyStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(),
+ vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList,
+ vk::Bool32 primitiveRestartEnable_ = 0 )
+ : layout::PipelineInputAssemblyStateCreateInfo( flags_, topology_, primitiveRestartEnable_ )
{}
PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
- }
+ : layout::PipelineInputAssemblyStateCreateInfo( rhs )
+ {}
PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
+ layout::PipelineInputAssemblyStateCreateInfo::operator=(rhs);
return *this;
}
@@ -30011,19 +36229,19 @@
return *this;
}
- PipelineInputAssemblyStateCreateInfo & setFlags( PipelineInputAssemblyStateCreateFlags flags_ )
+ PipelineInputAssemblyStateCreateInfo & setFlags( vk::PipelineInputAssemblyStateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineInputAssemblyStateCreateInfo & setTopology( PrimitiveTopology topology_ )
+ PipelineInputAssemblyStateCreateInfo & setTopology( vk::PrimitiveTopology topology_ )
{
topology = topology_;
return *this;
}
- PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ )
+ PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( vk::Bool32 primitiveRestartEnable_ )
{
primitiveRestartEnable = primitiveRestartEnable_;
return *this;
@@ -30054,32 +36272,56 @@
}
private:
- StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineInputAssemblyStateCreateFlags flags;
- PrimitiveTopology topology;
- Bool32 primitiveRestartEnable;
+ using layout::PipelineInputAssemblyStateCreateInfo::sType;
};
static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineInputAssemblyStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineTessellationStateCreateInfo
+ namespace layout
{
- PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(),
- uint32_t patchControlPoints_ = 0 )
- : flags( flags_ )
- , patchControlPoints( patchControlPoints_ )
+ struct PipelineTessellationStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(),
+ uint32_t patchControlPoints_ = 0 )
+ : flags( flags_ )
+ , patchControlPoints( patchControlPoints_ )
+ {}
+
+ PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineTessellationStateCreateFlags flags;
+ uint32_t patchControlPoints;
+ };
+ static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineTessellationStateCreateInfo : public layout::PipelineTessellationStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(),
+ uint32_t patchControlPoints_ = 0 )
+ : layout::PipelineTessellationStateCreateInfo( flags_, patchControlPoints_ )
{}
PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
- }
+ : layout::PipelineTessellationStateCreateInfo( rhs )
+ {}
PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
+ layout::PipelineTessellationStateCreateInfo::operator=(rhs);
return *this;
}
@@ -30089,7 +36331,7 @@
return *this;
}
- PipelineTessellationStateCreateInfo & setFlags( PipelineTessellationStateCreateFlags flags_ )
+ PipelineTessellationStateCreateInfo & setFlags( vk::PipelineTessellationStateCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -30125,23 +36367,19 @@
}
private:
- StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineTessellationStateCreateFlags flags;
- uint32_t patchControlPoints;
+ using layout::PipelineTessellationStateCreateInfo::sType;
};
static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineTessellationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct Viewport
{
- Viewport( float x_ = 0,
- float y_ = 0,
- float width_ = 0,
- float height_ = 0,
- float minDepth_ = 0,
- float maxDepth_ = 0 )
+ VULKAN_HPP_CONSTEXPR Viewport( float x_ = 0,
+ float y_ = 0,
+ float width_ = 0,
+ float height_ = 0,
+ float minDepth_ = 0,
+ float maxDepth_ = 0 )
: x( x_ )
, y( y_ )
, width( width_ )
@@ -30152,12 +36390,12 @@
Viewport( VkViewport const & rhs )
{
- memcpy( this, &rhs, sizeof( Viewport ) );
+ *reinterpret_cast<VkViewport*>(this) = rhs;
}
Viewport& operator=( VkViewport const & rhs )
{
- memcpy( this, &rhs, sizeof( Viewport ) );
+ *reinterpret_cast<VkViewport*>(this) = rhs;
return *this;
}
@@ -30222,6 +36460,7 @@
return !operator==( rhs );
}
+ public:
float x;
float y;
float width;
@@ -30230,29 +36469,65 @@
float maxDepth;
};
static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Viewport>::value, "struct wrapper is not a standard layout!" );
- struct PipelineViewportStateCreateInfo
+ namespace layout
{
- PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(),
- uint32_t viewportCount_ = 0,
- const Viewport* pViewports_ = nullptr,
- uint32_t scissorCount_ = 0,
- const Rect2D* pScissors_ = nullptr )
- : flags( flags_ )
- , viewportCount( viewportCount_ )
- , pViewports( pViewports_ )
- , scissorCount( scissorCount_ )
- , pScissors( pScissors_ )
+ struct PipelineViewportStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(),
+ uint32_t viewportCount_ = 0,
+ const vk::Viewport* pViewports_ = nullptr,
+ uint32_t scissorCount_ = 0,
+ const vk::Rect2D* pScissors_ = nullptr )
+ : flags( flags_ )
+ , viewportCount( viewportCount_ )
+ , pViewports( pViewports_ )
+ , scissorCount( scissorCount_ )
+ , pScissors( pScissors_ )
+ {}
+
+ PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineViewportStateCreateFlags flags;
+ uint32_t viewportCount;
+ const vk::Viewport* pViewports;
+ uint32_t scissorCount;
+ const vk::Rect2D* pScissors;
+ };
+ static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineViewportStateCreateInfo : public layout::PipelineViewportStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(),
+ uint32_t viewportCount_ = 0,
+ const vk::Viewport* pViewports_ = nullptr,
+ uint32_t scissorCount_ = 0,
+ const vk::Rect2D* pScissors_ = nullptr )
+ : layout::PipelineViewportStateCreateInfo( flags_, viewportCount_, pViewports_, scissorCount_, pScissors_ )
{}
PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
- }
+ : layout::PipelineViewportStateCreateInfo( rhs )
+ {}
PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
+ layout::PipelineViewportStateCreateInfo::operator=(rhs);
return *this;
}
@@ -30262,7 +36537,7 @@
return *this;
}
- PipelineViewportStateCreateInfo & setFlags( PipelineViewportStateCreateFlags flags_ )
+ PipelineViewportStateCreateInfo & setFlags( vk::PipelineViewportStateCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -30274,7 +36549,7 @@
return *this;
}
- PipelineViewportStateCreateInfo & setPViewports( const Viewport* pViewports_ )
+ PipelineViewportStateCreateInfo & setPViewports( const vk::Viewport* pViewports_ )
{
pViewports = pViewports_;
return *this;
@@ -30286,7 +36561,7 @@
return *this;
}
- PipelineViewportStateCreateInfo & setPScissors( const Rect2D* pScissors_ )
+ PipelineViewportStateCreateInfo & setPScissors( const vk::Rect2D* pScissors_ )
{
pScissors = pScissors_;
return *this;
@@ -30319,52 +36594,92 @@
}
private:
- StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineViewportStateCreateFlags flags;
- uint32_t viewportCount;
- const Viewport* pViewports;
- uint32_t scissorCount;
- const Rect2D* pScissors;
+ using layout::PipelineViewportStateCreateInfo::sType;
};
static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineViewportStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineRasterizationStateCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , depthClampEnable( depthClampEnable_ )
- , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
- , polygonMode( polygonMode_ )
- , cullMode( cullMode_ )
- , frontFace( frontFace_ )
- , depthBiasEnable( depthBiasEnable_ )
- , depthBiasConstantFactor( depthBiasConstantFactor_ )
- , depthBiasClamp( depthBiasClamp_ )
- , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
- , lineWidth( lineWidth_ )
+ struct PipelineRasterizationStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(),
+ vk::Bool32 depthClampEnable_ = 0,
+ vk::Bool32 rasterizerDiscardEnable_ = 0,
+ vk::PolygonMode polygonMode_ = vk::PolygonMode::eFill,
+ vk::CullModeFlags cullMode_ = vk::CullModeFlags(),
+ vk::FrontFace frontFace_ = vk::FrontFace::eCounterClockwise,
+ vk::Bool32 depthBiasEnable_ = 0,
+ float depthBiasConstantFactor_ = 0,
+ float depthBiasClamp_ = 0,
+ float depthBiasSlopeFactor_ = 0,
+ float lineWidth_ = 0 )
+ : flags( flags_ )
+ , depthClampEnable( depthClampEnable_ )
+ , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
+ , polygonMode( polygonMode_ )
+ , cullMode( cullMode_ )
+ , frontFace( frontFace_ )
+ , depthBiasEnable( depthBiasEnable_ )
+ , depthBiasConstantFactor( depthBiasConstantFactor_ )
+ , depthBiasClamp( depthBiasClamp_ )
+ , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
+ , lineWidth( lineWidth_ )
+ {}
+
+ PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineRasterizationStateCreateFlags flags;
+ vk::Bool32 depthClampEnable;
+ vk::Bool32 rasterizerDiscardEnable;
+ vk::PolygonMode polygonMode;
+ vk::CullModeFlags cullMode;
+ vk::FrontFace frontFace;
+ vk::Bool32 depthBiasEnable;
+ float depthBiasConstantFactor;
+ float depthBiasClamp;
+ float depthBiasSlopeFactor;
+ float lineWidth;
+ };
+ static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRasterizationStateCreateInfo : public layout::PipelineRasterizationStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(),
+ vk::Bool32 depthClampEnable_ = 0,
+ vk::Bool32 rasterizerDiscardEnable_ = 0,
+ vk::PolygonMode polygonMode_ = vk::PolygonMode::eFill,
+ vk::CullModeFlags cullMode_ = vk::CullModeFlags(),
+ vk::FrontFace frontFace_ = vk::FrontFace::eCounterClockwise,
+ vk::Bool32 depthBiasEnable_ = 0,
+ float depthBiasConstantFactor_ = 0,
+ float depthBiasClamp_ = 0,
+ float depthBiasSlopeFactor_ = 0,
+ float lineWidth_ = 0 )
+ : layout::PipelineRasterizationStateCreateInfo( flags_, depthClampEnable_, rasterizerDiscardEnable_, polygonMode_, cullMode_, frontFace_, depthBiasEnable_, depthBiasConstantFactor_, depthBiasClamp_, depthBiasSlopeFactor_, lineWidth_ )
{}
PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
- }
+ : layout::PipelineRasterizationStateCreateInfo( rhs )
+ {}
PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
+ layout::PipelineRasterizationStateCreateInfo::operator=(rhs);
return *this;
}
@@ -30374,43 +36689,43 @@
return *this;
}
- PipelineRasterizationStateCreateInfo & setFlags( PipelineRasterizationStateCreateFlags flags_ )
+ PipelineRasterizationStateCreateInfo & setFlags( vk::PipelineRasterizationStateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineRasterizationStateCreateInfo & setDepthClampEnable( Bool32 depthClampEnable_ )
+ PipelineRasterizationStateCreateInfo & setDepthClampEnable( vk::Bool32 depthClampEnable_ )
{
depthClampEnable = depthClampEnable_;
return *this;
}
- PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ )
+ PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( vk::Bool32 rasterizerDiscardEnable_ )
{
rasterizerDiscardEnable = rasterizerDiscardEnable_;
return *this;
}
- PipelineRasterizationStateCreateInfo & setPolygonMode( PolygonMode polygonMode_ )
+ PipelineRasterizationStateCreateInfo & setPolygonMode( vk::PolygonMode polygonMode_ )
{
polygonMode = polygonMode_;
return *this;
}
- PipelineRasterizationStateCreateInfo & setCullMode( CullModeFlags cullMode_ )
+ PipelineRasterizationStateCreateInfo & setCullMode( vk::CullModeFlags cullMode_ )
{
cullMode = cullMode_;
return *this;
}
- PipelineRasterizationStateCreateInfo & setFrontFace( FrontFace frontFace_ )
+ PipelineRasterizationStateCreateInfo & setFrontFace( vk::FrontFace frontFace_ )
{
frontFace = frontFace_;
return *this;
}
- PipelineRasterizationStateCreateInfo & setDepthBiasEnable( Bool32 depthBiasEnable_ )
+ PipelineRasterizationStateCreateInfo & setDepthBiasEnable( vk::Bool32 depthBiasEnable_ )
{
depthBiasEnable = depthBiasEnable_;
return *this;
@@ -30473,50 +36788,76 @@
}
private:
- StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineRasterizationStateCreateFlags flags;
- Bool32 depthClampEnable;
- Bool32 rasterizerDiscardEnable;
- PolygonMode polygonMode;
- CullModeFlags cullMode;
- FrontFace frontFace;
- Bool32 depthBiasEnable;
- float depthBiasConstantFactor;
- float depthBiasClamp;
- float depthBiasSlopeFactor;
- float lineWidth;
+ using layout::PipelineRasterizationStateCreateInfo::sType;
};
static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRasterizationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineMultisampleStateCreateInfo
+ namespace layout
{
- PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(),
- SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1,
- Bool32 sampleShadingEnable_ = 0,
- float minSampleShading_ = 0,
- const SampleMask* pSampleMask_ = nullptr,
- Bool32 alphaToCoverageEnable_ = 0,
- Bool32 alphaToOneEnable_ = 0 )
- : flags( flags_ )
- , rasterizationSamples( rasterizationSamples_ )
- , sampleShadingEnable( sampleShadingEnable_ )
- , minSampleShading( minSampleShading_ )
- , pSampleMask( pSampleMask_ )
- , alphaToCoverageEnable( alphaToCoverageEnable_ )
- , alphaToOneEnable( alphaToOneEnable_ )
+ struct PipelineMultisampleStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(),
+ vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
+ vk::Bool32 sampleShadingEnable_ = 0,
+ float minSampleShading_ = 0,
+ const vk::SampleMask* pSampleMask_ = nullptr,
+ vk::Bool32 alphaToCoverageEnable_ = 0,
+ vk::Bool32 alphaToOneEnable_ = 0 )
+ : flags( flags_ )
+ , rasterizationSamples( rasterizationSamples_ )
+ , sampleShadingEnable( sampleShadingEnable_ )
+ , minSampleShading( minSampleShading_ )
+ , pSampleMask( pSampleMask_ )
+ , alphaToCoverageEnable( alphaToCoverageEnable_ )
+ , alphaToOneEnable( alphaToOneEnable_ )
+ {}
+
+ PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineMultisampleStateCreateFlags flags;
+ vk::SampleCountFlagBits rasterizationSamples;
+ vk::Bool32 sampleShadingEnable;
+ float minSampleShading;
+ const vk::SampleMask* pSampleMask;
+ vk::Bool32 alphaToCoverageEnable;
+ vk::Bool32 alphaToOneEnable;
+ };
+ static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineMultisampleStateCreateInfo : public layout::PipelineMultisampleStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(),
+ vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1,
+ vk::Bool32 sampleShadingEnable_ = 0,
+ float minSampleShading_ = 0,
+ const vk::SampleMask* pSampleMask_ = nullptr,
+ vk::Bool32 alphaToCoverageEnable_ = 0,
+ vk::Bool32 alphaToOneEnable_ = 0 )
+ : layout::PipelineMultisampleStateCreateInfo( flags_, rasterizationSamples_, sampleShadingEnable_, minSampleShading_, pSampleMask_, alphaToCoverageEnable_, alphaToOneEnable_ )
{}
PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
- }
+ : layout::PipelineMultisampleStateCreateInfo( rhs )
+ {}
PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
+ layout::PipelineMultisampleStateCreateInfo::operator=(rhs);
return *this;
}
@@ -30526,19 +36867,19 @@
return *this;
}
- PipelineMultisampleStateCreateInfo & setFlags( PipelineMultisampleStateCreateFlags flags_ )
+ PipelineMultisampleStateCreateInfo & setFlags( vk::PipelineMultisampleStateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineMultisampleStateCreateInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
+ PipelineMultisampleStateCreateInfo & setRasterizationSamples( vk::SampleCountFlagBits rasterizationSamples_ )
{
rasterizationSamples = rasterizationSamples_;
return *this;
}
- PipelineMultisampleStateCreateInfo & setSampleShadingEnable( Bool32 sampleShadingEnable_ )
+ PipelineMultisampleStateCreateInfo & setSampleShadingEnable( vk::Bool32 sampleShadingEnable_ )
{
sampleShadingEnable = sampleShadingEnable_;
return *this;
@@ -30550,19 +36891,19 @@
return *this;
}
- PipelineMultisampleStateCreateInfo & setPSampleMask( const SampleMask* pSampleMask_ )
+ PipelineMultisampleStateCreateInfo & setPSampleMask( const vk::SampleMask* pSampleMask_ )
{
pSampleMask = pSampleMask_;
return *this;
}
- PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
+ PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( vk::Bool32 alphaToCoverageEnable_ )
{
alphaToCoverageEnable = alphaToCoverageEnable_;
return *this;
}
- PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
+ PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( vk::Bool32 alphaToOneEnable_ )
{
alphaToOneEnable = alphaToOneEnable_;
return *this;
@@ -30597,29 +36938,20 @@
}
private:
- StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineMultisampleStateCreateFlags flags;
- SampleCountFlagBits rasterizationSamples;
- Bool32 sampleShadingEnable;
- float minSampleShading;
- const SampleMask* pSampleMask;
- Bool32 alphaToCoverageEnable;
- Bool32 alphaToOneEnable;
+ using layout::PipelineMultisampleStateCreateInfo::sType;
};
static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineMultisampleStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct StencilOpState
{
- 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 )
+ VULKAN_HPP_CONSTEXPR StencilOpState( vk::StencilOp failOp_ = vk::StencilOp::eKeep,
+ vk::StencilOp passOp_ = vk::StencilOp::eKeep,
+ vk::StencilOp depthFailOp_ = vk::StencilOp::eKeep,
+ vk::CompareOp compareOp_ = vk::CompareOp::eNever,
+ uint32_t compareMask_ = 0,
+ uint32_t writeMask_ = 0,
+ uint32_t reference_ = 0 )
: failOp( failOp_ )
, passOp( passOp_ )
, depthFailOp( depthFailOp_ )
@@ -30631,34 +36963,34 @@
StencilOpState( VkStencilOpState const & rhs )
{
- memcpy( this, &rhs, sizeof( StencilOpState ) );
+ *reinterpret_cast<VkStencilOpState*>(this) = rhs;
}
StencilOpState& operator=( VkStencilOpState const & rhs )
{
- memcpy( this, &rhs, sizeof( StencilOpState ) );
+ *reinterpret_cast<VkStencilOpState*>(this) = rhs;
return *this;
}
- StencilOpState & setFailOp( StencilOp failOp_ )
+ StencilOpState & setFailOp( vk::StencilOp failOp_ )
{
failOp = failOp_;
return *this;
}
- StencilOpState & setPassOp( StencilOp passOp_ )
+ StencilOpState & setPassOp( vk::StencilOp passOp_ )
{
passOp = passOp_;
return *this;
}
- StencilOpState & setDepthFailOp( StencilOp depthFailOp_ )
+ StencilOpState & setDepthFailOp( vk::StencilOp depthFailOp_ )
{
depthFailOp = depthFailOp_;
return *this;
}
- StencilOpState & setCompareOp( CompareOp compareOp_ )
+ StencilOpState & setCompareOp( vk::CompareOp compareOp_ )
{
compareOp = compareOp_;
return *this;
@@ -30708,48 +37040,95 @@
return !operator==( rhs );
}
- StencilOp failOp;
- StencilOp passOp;
- StencilOp depthFailOp;
- CompareOp compareOp;
+ public:
+ vk::StencilOp failOp;
+ vk::StencilOp passOp;
+ vk::StencilOp depthFailOp;
+ vk::CompareOp compareOp;
uint32_t compareMask;
uint32_t writeMask;
uint32_t reference;
};
static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<StencilOpState>::value, "struct wrapper is not a standard layout!" );
- struct PipelineDepthStencilStateCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , depthTestEnable( depthTestEnable_ )
- , depthWriteEnable( depthWriteEnable_ )
- , depthCompareOp( depthCompareOp_ )
- , depthBoundsTestEnable( depthBoundsTestEnable_ )
- , stencilTestEnable( stencilTestEnable_ )
- , front( front_ )
- , back( back_ )
- , minDepthBounds( minDepthBounds_ )
- , maxDepthBounds( maxDepthBounds_ )
+ struct PipelineDepthStencilStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(),
+ vk::Bool32 depthTestEnable_ = 0,
+ vk::Bool32 depthWriteEnable_ = 0,
+ vk::CompareOp depthCompareOp_ = vk::CompareOp::eNever,
+ vk::Bool32 depthBoundsTestEnable_ = 0,
+ vk::Bool32 stencilTestEnable_ = 0,
+ vk::StencilOpState front_ = vk::StencilOpState(),
+ vk::StencilOpState back_ = vk::StencilOpState(),
+ float minDepthBounds_ = 0,
+ float maxDepthBounds_ = 0 )
+ : flags( flags_ )
+ , depthTestEnable( depthTestEnable_ )
+ , depthWriteEnable( depthWriteEnable_ )
+ , depthCompareOp( depthCompareOp_ )
+ , depthBoundsTestEnable( depthBoundsTestEnable_ )
+ , stencilTestEnable( stencilTestEnable_ )
+ , front( front_ )
+ , back( back_ )
+ , minDepthBounds( minDepthBounds_ )
+ , maxDepthBounds( maxDepthBounds_ )
+ {}
+
+ PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineDepthStencilStateCreateFlags flags;
+ vk::Bool32 depthTestEnable;
+ vk::Bool32 depthWriteEnable;
+ vk::CompareOp depthCompareOp;
+ vk::Bool32 depthBoundsTestEnable;
+ vk::Bool32 stencilTestEnable;
+ vk::StencilOpState front;
+ vk::StencilOpState back;
+ float minDepthBounds;
+ float maxDepthBounds;
+ };
+ static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineDepthStencilStateCreateInfo : public layout::PipelineDepthStencilStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(),
+ vk::Bool32 depthTestEnable_ = 0,
+ vk::Bool32 depthWriteEnable_ = 0,
+ vk::CompareOp depthCompareOp_ = vk::CompareOp::eNever,
+ vk::Bool32 depthBoundsTestEnable_ = 0,
+ vk::Bool32 stencilTestEnable_ = 0,
+ vk::StencilOpState front_ = vk::StencilOpState(),
+ vk::StencilOpState back_ = vk::StencilOpState(),
+ float minDepthBounds_ = 0,
+ float maxDepthBounds_ = 0 )
+ : layout::PipelineDepthStencilStateCreateInfo( flags_, depthTestEnable_, depthWriteEnable_, depthCompareOp_, depthBoundsTestEnable_, stencilTestEnable_, front_, back_, minDepthBounds_, maxDepthBounds_ )
{}
PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
- }
+ : layout::PipelineDepthStencilStateCreateInfo( rhs )
+ {}
PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
+ layout::PipelineDepthStencilStateCreateInfo::operator=(rhs);
return *this;
}
@@ -30759,49 +37138,49 @@
return *this;
}
- PipelineDepthStencilStateCreateInfo & setFlags( PipelineDepthStencilStateCreateFlags flags_ )
+ PipelineDepthStencilStateCreateInfo & setFlags( vk::PipelineDepthStencilStateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setDepthTestEnable( Bool32 depthTestEnable_ )
+ PipelineDepthStencilStateCreateInfo & setDepthTestEnable( vk::Bool32 depthTestEnable_ )
{
depthTestEnable = depthTestEnable_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( Bool32 depthWriteEnable_ )
+ PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( vk::Bool32 depthWriteEnable_ )
{
depthWriteEnable = depthWriteEnable_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setDepthCompareOp( CompareOp depthCompareOp_ )
+ PipelineDepthStencilStateCreateInfo & setDepthCompareOp( vk::CompareOp depthCompareOp_ )
{
depthCompareOp = depthCompareOp_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ )
+ PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( vk::Bool32 depthBoundsTestEnable_ )
{
depthBoundsTestEnable = depthBoundsTestEnable_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setStencilTestEnable( Bool32 stencilTestEnable_ )
+ PipelineDepthStencilStateCreateInfo & setStencilTestEnable( vk::Bool32 stencilTestEnable_ )
{
stencilTestEnable = stencilTestEnable_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setFront( StencilOpState front_ )
+ PipelineDepthStencilStateCreateInfo & setFront( vk::StencilOpState front_ )
{
front = front_;
return *this;
}
- PipelineDepthStencilStateCreateInfo & setBack( StencilOpState back_ )
+ PipelineDepthStencilStateCreateInfo & setBack( vk::StencilOpState back_ )
{
back = back_;
return *this;
@@ -30851,33 +37230,21 @@
}
private:
- StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineDepthStencilStateCreateFlags flags;
- Bool32 depthTestEnable;
- Bool32 depthWriteEnable;
- CompareOp depthCompareOp;
- Bool32 depthBoundsTestEnable;
- Bool32 stencilTestEnable;
- StencilOpState front;
- StencilOpState back;
- float minDepthBounds;
- float maxDepthBounds;
+ using layout::PipelineDepthStencilStateCreateInfo::sType;
};
static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineDepthStencilStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct PipelineColorBlendAttachmentState
{
- 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() )
+ VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( vk::Bool32 blendEnable_ = 0,
+ vk::BlendFactor srcColorBlendFactor_ = vk::BlendFactor::eZero,
+ vk::BlendFactor dstColorBlendFactor_ = vk::BlendFactor::eZero,
+ vk::BlendOp colorBlendOp_ = vk::BlendOp::eAdd,
+ vk::BlendFactor srcAlphaBlendFactor_ = vk::BlendFactor::eZero,
+ vk::BlendFactor dstAlphaBlendFactor_ = vk::BlendFactor::eZero,
+ vk::BlendOp alphaBlendOp_ = vk::BlendOp::eAdd,
+ vk::ColorComponentFlags colorWriteMask_ = vk::ColorComponentFlags() )
: blendEnable( blendEnable_ )
, srcColorBlendFactor( srcColorBlendFactor_ )
, dstColorBlendFactor( dstColorBlendFactor_ )
@@ -30890,58 +37257,58 @@
PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+ *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this) = rhs;
}
PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
+ *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this) = rhs;
return *this;
}
- PipelineColorBlendAttachmentState & setBlendEnable( Bool32 blendEnable_ )
+ PipelineColorBlendAttachmentState & setBlendEnable( vk::Bool32 blendEnable_ )
{
blendEnable = blendEnable_;
return *this;
}
- PipelineColorBlendAttachmentState & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
+ PipelineColorBlendAttachmentState & setSrcColorBlendFactor( vk::BlendFactor srcColorBlendFactor_ )
{
srcColorBlendFactor = srcColorBlendFactor_;
return *this;
}
- PipelineColorBlendAttachmentState & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
+ PipelineColorBlendAttachmentState & setDstColorBlendFactor( vk::BlendFactor dstColorBlendFactor_ )
{
dstColorBlendFactor = dstColorBlendFactor_;
return *this;
}
- PipelineColorBlendAttachmentState & setColorBlendOp( BlendOp colorBlendOp_ )
+ PipelineColorBlendAttachmentState & setColorBlendOp( vk::BlendOp colorBlendOp_ )
{
colorBlendOp = colorBlendOp_;
return *this;
}
- PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
+ PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( vk::BlendFactor srcAlphaBlendFactor_ )
{
srcAlphaBlendFactor = srcAlphaBlendFactor_;
return *this;
}
- PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
+ PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( vk::BlendFactor dstAlphaBlendFactor_ )
{
dstAlphaBlendFactor = dstAlphaBlendFactor_;
return *this;
}
- PipelineColorBlendAttachmentState & setAlphaBlendOp( BlendOp alphaBlendOp_ )
+ PipelineColorBlendAttachmentState & setAlphaBlendOp( vk::BlendOp alphaBlendOp_ )
{
alphaBlendOp = alphaBlendOp_;
return *this;
}
- PipelineColorBlendAttachmentState & setColorWriteMask( ColorComponentFlags colorWriteMask_ )
+ PipelineColorBlendAttachmentState & setColorWriteMask( vk::ColorComponentFlags colorWriteMask_ )
{
colorWriteMask = colorWriteMask_;
return *this;
@@ -30974,42 +37341,82 @@
return !operator==( rhs );
}
- Bool32 blendEnable;
- BlendFactor srcColorBlendFactor;
- BlendFactor dstColorBlendFactor;
- BlendOp colorBlendOp;
- BlendFactor srcAlphaBlendFactor;
- BlendFactor dstAlphaBlendFactor;
- BlendOp alphaBlendOp;
- ColorComponentFlags colorWriteMask;
+ public:
+ vk::Bool32 blendEnable;
+ vk::BlendFactor srcColorBlendFactor;
+ vk::BlendFactor dstColorBlendFactor;
+ vk::BlendOp colorBlendOp;
+ vk::BlendFactor srcAlphaBlendFactor;
+ vk::BlendFactor dstAlphaBlendFactor;
+ vk::BlendOp alphaBlendOp;
+ vk::ColorComponentFlags colorWriteMask;
};
static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineColorBlendAttachmentState>::value, "struct wrapper is not a standard layout!" );
- struct PipelineColorBlendStateCreateInfo
+ namespace layout
{
- 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 } } )
- : flags( flags_ )
- , logicOpEnable( logicOpEnable_ )
- , logicOp( logicOp_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
+ struct PipelineColorBlendStateCreateInfo
{
- memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
- }
+ protected:
+ VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(),
+ vk::Bool32 logicOpEnable_ = 0,
+ vk::LogicOp logicOp_ = vk::LogicOp::eClear,
+ uint32_t attachmentCount_ = 0,
+ const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
+ std::array<float,4> const& blendConstants_ = { { 0 } } )
+ : flags( flags_ )
+ , logicOpEnable( logicOpEnable_ )
+ , logicOp( logicOp_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , blendConstants{}
+ {
+ vk::ConstExpressionArrayCopy<float,4,4>::copy( blendConstants, blendConstants_ );
+ }
+
+ PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineColorBlendStateCreateFlags flags;
+ vk::Bool32 logicOpEnable;
+ vk::LogicOp logicOp;
+ uint32_t attachmentCount;
+ const vk::PipelineColorBlendAttachmentState* pAttachments;
+ float blendConstants[4];
+ };
+ static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineColorBlendStateCreateInfo : public layout::PipelineColorBlendStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(),
+ vk::Bool32 logicOpEnable_ = 0,
+ vk::LogicOp logicOp_ = vk::LogicOp::eClear,
+ uint32_t attachmentCount_ = 0,
+ const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
+ std::array<float,4> const& blendConstants_ = { { 0 } } )
+ : layout::PipelineColorBlendStateCreateInfo( flags_, logicOpEnable_, logicOp_, attachmentCount_, pAttachments_, blendConstants_ )
+ {}
PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
- }
+ : layout::PipelineColorBlendStateCreateInfo( rhs )
+ {}
PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
+ layout::PipelineColorBlendStateCreateInfo::operator=(rhs);
return *this;
}
@@ -31019,19 +37426,19 @@
return *this;
}
- PipelineColorBlendStateCreateInfo & setFlags( PipelineColorBlendStateCreateFlags flags_ )
+ PipelineColorBlendStateCreateInfo & setFlags( vk::PipelineColorBlendStateCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PipelineColorBlendStateCreateInfo & setLogicOpEnable( Bool32 logicOpEnable_ )
+ PipelineColorBlendStateCreateInfo & setLogicOpEnable( vk::Bool32 logicOpEnable_ )
{
logicOpEnable = logicOpEnable_;
return *this;
}
- PipelineColorBlendStateCreateInfo & setLogicOp( LogicOp logicOp_ )
+ PipelineColorBlendStateCreateInfo & setLogicOp( vk::LogicOp logicOp_ )
{
logicOp = logicOp_;
return *this;
@@ -31043,7 +37450,7 @@
return *this;
}
- PipelineColorBlendStateCreateInfo & setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
+ PipelineColorBlendStateCreateInfo & setPAttachments( const vk::PipelineColorBlendAttachmentState* pAttachments_ )
{
pAttachments = pAttachments_;
return *this;
@@ -31083,37 +37490,60 @@
}
private:
- StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineColorBlendStateCreateFlags flags;
- Bool32 logicOpEnable;
- LogicOp logicOp;
- uint32_t attachmentCount;
- const PipelineColorBlendAttachmentState* pAttachments;
- float blendConstants[4];
+ using layout::PipelineColorBlendStateCreateInfo::sType;
};
static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineColorBlendStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineDynamicStateCreateInfo
+ namespace layout
{
- PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(),
- uint32_t dynamicStateCount_ = 0,
- const DynamicState* pDynamicStates_ = nullptr )
- : flags( flags_ )
- , dynamicStateCount( dynamicStateCount_ )
- , pDynamicStates( pDynamicStates_ )
+ struct PipelineDynamicStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(),
+ uint32_t dynamicStateCount_ = 0,
+ const vk::DynamicState* pDynamicStates_ = nullptr )
+ : flags( flags_ )
+ , dynamicStateCount( dynamicStateCount_ )
+ , pDynamicStates( pDynamicStates_ )
+ {}
+
+ PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineDynamicStateCreateFlags flags;
+ uint32_t dynamicStateCount;
+ const vk::DynamicState* pDynamicStates;
+ };
+ static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineDynamicStateCreateInfo : public layout::PipelineDynamicStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(),
+ uint32_t dynamicStateCount_ = 0,
+ const vk::DynamicState* pDynamicStates_ = nullptr )
+ : layout::PipelineDynamicStateCreateInfo( flags_, dynamicStateCount_, pDynamicStates_ )
{}
PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
- }
+ : layout::PipelineDynamicStateCreateInfo( rhs )
+ {}
PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
+ layout::PipelineDynamicStateCreateInfo::operator=(rhs);
return *this;
}
@@ -31123,7 +37553,7 @@
return *this;
}
- PipelineDynamicStateCreateInfo & setFlags( PipelineDynamicStateCreateFlags flags_ )
+ PipelineDynamicStateCreateInfo & setFlags( vk::PipelineDynamicStateCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -31135,7 +37565,7 @@
return *this;
}
- PipelineDynamicStateCreateInfo & setPDynamicStates( const DynamicState* pDynamicStates_ )
+ PipelineDynamicStateCreateInfo & setPDynamicStates( const vk::DynamicState* pDynamicStates_ )
{
pDynamicStates = pDynamicStates_;
return *this;
@@ -31166,62 +37596,116 @@
}
private:
- StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineDynamicStateCreateFlags flags;
- uint32_t dynamicStateCount;
- const DynamicState* pDynamicStates;
+ using layout::PipelineDynamicStateCreateInfo::sType;
};
static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineDynamicStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct GraphicsPipelineCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , stageCount( stageCount_ )
- , pStages( pStages_ )
- , pVertexInputState( pVertexInputState_ )
- , pInputAssemblyState( pInputAssemblyState_ )
- , pTessellationState( pTessellationState_ )
- , pViewportState( pViewportState_ )
- , pRasterizationState( pRasterizationState_ )
- , pMultisampleState( pMultisampleState_ )
- , pDepthStencilState( pDepthStencilState_ )
- , pColorBlendState( pColorBlendState_ )
- , pDynamicState( pDynamicState_ )
- , layout( layout_ )
- , renderPass( renderPass_ )
- , subpass( subpass_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
+ struct GraphicsPipelineCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+ uint32_t stageCount_ = 0,
+ const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+ const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
+ const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
+ const vk::PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
+ const vk::PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
+ const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
+ const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
+ const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
+ const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
+ const vk::PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
+ vk::PipelineLayout layout_ = vk::PipelineLayout(),
+ vk::RenderPass renderPass_ = vk::RenderPass(),
+ uint32_t subpass_ = 0,
+ vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : flags( flags_ )
+ , stageCount( stageCount_ )
+ , pStages( pStages_ )
+ , pVertexInputState( pVertexInputState_ )
+ , pInputAssemblyState( pInputAssemblyState_ )
+ , pTessellationState( pTessellationState_ )
+ , pViewportState( pViewportState_ )
+ , pRasterizationState( pRasterizationState_ )
+ , pMultisampleState( pMultisampleState_ )
+ , pDepthStencilState( pDepthStencilState_ )
+ , pColorBlendState( pColorBlendState_ )
+ , pDynamicState( pDynamicState_ )
+ , layout( layout_ )
+ , renderPass( renderPass_ )
+ , subpass( subpass_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
+ {}
+
+ GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this) = rhs;
+ }
+
+ GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineCreateFlags flags;
+ uint32_t stageCount;
+ const vk::PipelineShaderStageCreateInfo* pStages;
+ const vk::PipelineVertexInputStateCreateInfo* pVertexInputState;
+ const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ const vk::PipelineTessellationStateCreateInfo* pTessellationState;
+ const vk::PipelineViewportStateCreateInfo* pViewportState;
+ const vk::PipelineRasterizationStateCreateInfo* pRasterizationState;
+ const vk::PipelineMultisampleStateCreateInfo* pMultisampleState;
+ const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ const vk::PipelineColorBlendStateCreateInfo* pColorBlendState;
+ const vk::PipelineDynamicStateCreateInfo* pDynamicState;
+ vk::PipelineLayout layout;
+ vk::RenderPass renderPass;
+ uint32_t subpass;
+ vk::Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ };
+ static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct GraphicsPipelineCreateInfo : public layout::GraphicsPipelineCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+ uint32_t stageCount_ = 0,
+ const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+ const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
+ const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
+ const vk::PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
+ const vk::PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
+ const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
+ const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
+ const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
+ const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
+ const vk::PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
+ vk::PipelineLayout layout_ = vk::PipelineLayout(),
+ vk::RenderPass renderPass_ = vk::RenderPass(),
+ uint32_t subpass_ = 0,
+ vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : layout::GraphicsPipelineCreateInfo( flags_, stageCount_, pStages_, pVertexInputState_, pInputAssemblyState_, pTessellationState_, pViewportState_, pRasterizationState_, pMultisampleState_, pDepthStencilState_, pColorBlendState_, pDynamicState_, layout_, renderPass_, subpass_, basePipelineHandle_, basePipelineIndex_ )
{}
GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
- }
+ : layout::GraphicsPipelineCreateInfo( rhs )
+ {}
GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
+ layout::GraphicsPipelineCreateInfo::operator=(rhs);
return *this;
}
@@ -31231,7 +37715,7 @@
return *this;
}
- GraphicsPipelineCreateInfo & setFlags( PipelineCreateFlags flags_ )
+ GraphicsPipelineCreateInfo & setFlags( vk::PipelineCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -31243,73 +37727,73 @@
return *this;
}
- GraphicsPipelineCreateInfo & setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+ GraphicsPipelineCreateInfo & setPStages( const vk::PipelineShaderStageCreateInfo* pStages_ )
{
pStages = pStages_;
return *this;
}
- GraphicsPipelineCreateInfo & setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
+ GraphicsPipelineCreateInfo & setPVertexInputState( const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ )
{
pVertexInputState = pVertexInputState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
+ GraphicsPipelineCreateInfo & setPInputAssemblyState( const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
{
pInputAssemblyState = pInputAssemblyState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
+ GraphicsPipelineCreateInfo & setPTessellationState( const vk::PipelineTessellationStateCreateInfo* pTessellationState_ )
{
pTessellationState = pTessellationState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
+ GraphicsPipelineCreateInfo & setPViewportState( const vk::PipelineViewportStateCreateInfo* pViewportState_ )
{
pViewportState = pViewportState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
+ GraphicsPipelineCreateInfo & setPRasterizationState( const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ )
{
pRasterizationState = pRasterizationState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
+ GraphicsPipelineCreateInfo & setPMultisampleState( const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ )
{
pMultisampleState = pMultisampleState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
+ GraphicsPipelineCreateInfo & setPDepthStencilState( const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
{
pDepthStencilState = pDepthStencilState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
+ GraphicsPipelineCreateInfo & setPColorBlendState( const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ )
{
pColorBlendState = pColorBlendState_;
return *this;
}
- GraphicsPipelineCreateInfo & setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
+ GraphicsPipelineCreateInfo & setPDynamicState( const vk::PipelineDynamicStateCreateInfo* pDynamicState_ )
{
pDynamicState = pDynamicState_;
return *this;
}
- GraphicsPipelineCreateInfo & setLayout( PipelineLayout layout_ )
+ GraphicsPipelineCreateInfo & setLayout( vk::PipelineLayout layout_ )
{
layout = layout_;
return *this;
}
- GraphicsPipelineCreateInfo & setRenderPass( RenderPass renderPass_ )
+ GraphicsPipelineCreateInfo & setRenderPass( vk::RenderPass renderPass_ )
{
renderPass = renderPass_;
return *this;
@@ -31321,7 +37805,7 @@
return *this;
}
- GraphicsPipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ GraphicsPipelineCreateInfo & setBasePipelineHandle( vk::Pipeline basePipelineHandle_ )
{
basePipelineHandle = basePipelineHandle_;
return *this;
@@ -31372,46 +37856,27 @@
}
private:
- StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineCreateFlags flags;
- uint32_t stageCount;
- const PipelineShaderStageCreateInfo* pStages;
- const PipelineVertexInputStateCreateInfo* pVertexInputState;
- const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
- const PipelineTessellationStateCreateInfo* pTessellationState;
- const PipelineViewportStateCreateInfo* pViewportState;
- const PipelineRasterizationStateCreateInfo* pRasterizationState;
- const PipelineMultisampleStateCreateInfo* pMultisampleState;
- const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
- const PipelineColorBlendStateCreateInfo* pColorBlendState;
- const PipelineDynamicStateCreateInfo* pDynamicState;
- PipelineLayout layout;
- RenderPass renderPass;
- uint32_t subpass;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
+ using layout::GraphicsPipelineCreateInfo::sType;
};
static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<GraphicsPipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct XYColorEXT
{
- XYColorEXT( float x_ = 0,
- float y_ = 0 )
+ VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = 0,
+ float y_ = 0 )
: x( x_ )
, y( y_ )
{}
XYColorEXT( VkXYColorEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( XYColorEXT ) );
+ *reinterpret_cast<VkXYColorEXT*>(this) = rhs;
}
XYColorEXT& operator=( VkXYColorEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( XYColorEXT ) );
+ *reinterpret_cast<VkXYColorEXT*>(this) = rhs;
return *this;
}
@@ -31448,39 +37913,82 @@
return !operator==( rhs );
}
+ public:
float x;
float y;
};
static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<XYColorEXT>::value, "struct wrapper is not a standard layout!" );
- struct HdrMetadataEXT
+ namespace layout
{
- HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(),
- XYColorEXT displayPrimaryGreen_ = XYColorEXT(),
- XYColorEXT displayPrimaryBlue_ = XYColorEXT(),
- XYColorEXT whitePoint_ = XYColorEXT(),
- float maxLuminance_ = 0,
- float minLuminance_ = 0,
- float maxContentLightLevel_ = 0,
- float maxFrameAverageLightLevel_ = 0 )
- : displayPrimaryRed( displayPrimaryRed_ )
- , displayPrimaryGreen( displayPrimaryGreen_ )
- , displayPrimaryBlue( displayPrimaryBlue_ )
- , whitePoint( whitePoint_ )
- , maxLuminance( maxLuminance_ )
- , minLuminance( minLuminance_ )
- , maxContentLightLevel( maxContentLightLevel_ )
- , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
+ struct HdrMetadataEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(),
+ vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(),
+ vk::XYColorEXT displayPrimaryBlue_ = vk::XYColorEXT(),
+ vk::XYColorEXT whitePoint_ = vk::XYColorEXT(),
+ float maxLuminance_ = 0,
+ float minLuminance_ = 0,
+ float maxContentLightLevel_ = 0,
+ float maxFrameAverageLightLevel_ = 0 )
+ : displayPrimaryRed( displayPrimaryRed_ )
+ , displayPrimaryGreen( displayPrimaryGreen_ )
+ , displayPrimaryBlue( displayPrimaryBlue_ )
+ , whitePoint( whitePoint_ )
+ , maxLuminance( maxLuminance_ )
+ , minLuminance( minLuminance_ )
+ , maxContentLightLevel( maxContentLightLevel_ )
+ , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
+ {}
+
+ HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
+ {
+ *reinterpret_cast<VkHdrMetadataEXT*>(this) = rhs;
+ }
+
+ HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs )
+ {
+ *reinterpret_cast<VkHdrMetadataEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eHdrMetadataEXT;
+ const void* pNext = nullptr;
+ vk::XYColorEXT displayPrimaryRed;
+ vk::XYColorEXT displayPrimaryGreen;
+ vk::XYColorEXT displayPrimaryBlue;
+ vk::XYColorEXT whitePoint;
+ float maxLuminance;
+ float minLuminance;
+ float maxContentLightLevel;
+ float maxFrameAverageLightLevel;
+ };
+ static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct HdrMetadataEXT : public layout::HdrMetadataEXT
+ {
+ VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(),
+ vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(),
+ vk::XYColorEXT displayPrimaryBlue_ = vk::XYColorEXT(),
+ vk::XYColorEXT whitePoint_ = vk::XYColorEXT(),
+ float maxLuminance_ = 0,
+ float minLuminance_ = 0,
+ float maxContentLightLevel_ = 0,
+ float maxFrameAverageLightLevel_ = 0 )
+ : layout::HdrMetadataEXT( displayPrimaryRed_, displayPrimaryGreen_, displayPrimaryBlue_, whitePoint_, maxLuminance_, minLuminance_, maxContentLightLevel_, maxFrameAverageLightLevel_ )
{}
HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
- }
+ : layout::HdrMetadataEXT( rhs )
+ {}
HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
+ layout::HdrMetadataEXT::operator=(rhs);
return *this;
}
@@ -31490,25 +37998,25 @@
return *this;
}
- HdrMetadataEXT & setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ )
+ HdrMetadataEXT & setDisplayPrimaryRed( vk::XYColorEXT displayPrimaryRed_ )
{
displayPrimaryRed = displayPrimaryRed_;
return *this;
}
- HdrMetadataEXT & setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ )
+ HdrMetadataEXT & setDisplayPrimaryGreen( vk::XYColorEXT displayPrimaryGreen_ )
{
displayPrimaryGreen = displayPrimaryGreen_;
return *this;
}
- HdrMetadataEXT & setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ )
+ HdrMetadataEXT & setDisplayPrimaryBlue( vk::XYColorEXT displayPrimaryBlue_ )
{
displayPrimaryBlue = displayPrimaryBlue_;
return *this;
}
- HdrMetadataEXT & setWhitePoint( XYColorEXT whitePoint_ )
+ HdrMetadataEXT & setWhitePoint( vk::XYColorEXT whitePoint_ )
{
whitePoint = whitePoint_;
return *this;
@@ -31568,35 +38076,52 @@
}
private:
- StructureType sType = StructureType::eHdrMetadataEXT;
-
- public:
- const void* pNext = nullptr;
- XYColorEXT displayPrimaryRed;
- XYColorEXT displayPrimaryGreen;
- XYColorEXT displayPrimaryBlue;
- XYColorEXT whitePoint;
- float maxLuminance;
- float minLuminance;
- float maxContentLightLevel;
- float maxFrameAverageLightLevel;
+ using layout::HdrMetadataEXT::sType;
};
static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<HdrMetadataEXT>::value, "struct wrapper is not a standard layout!" );
- struct HeadlessSurfaceCreateInfoEXT
+ namespace layout
{
- HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateFlagsEXT flags_ = HeadlessSurfaceCreateFlagsEXT() )
- : flags( flags_ )
+ struct HeadlessSurfaceCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() )
+ : flags( flags_ )
+ {}
+
+ HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
+ }
+
+ HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::HeadlessSurfaceCreateFlagsEXT flags;
+ };
+ static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct HeadlessSurfaceCreateInfoEXT : public layout::HeadlessSurfaceCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() )
+ : layout::HeadlessSurfaceCreateInfoEXT( flags_ )
{}
HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( HeadlessSurfaceCreateInfoEXT ) );
- }
+ : layout::HeadlessSurfaceCreateInfoEXT( rhs )
+ {}
HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( HeadlessSurfaceCreateInfoEXT ) );
+ layout::HeadlessSurfaceCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -31606,7 +38131,7 @@
return *this;
}
- HeadlessSurfaceCreateInfoEXT & setFlags( HeadlessSurfaceCreateFlagsEXT flags_ )
+ HeadlessSurfaceCreateInfoEXT & setFlags( vk::HeadlessSurfaceCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -31635,31 +38160,58 @@
}
private:
- StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- HeadlessSurfaceCreateFlagsEXT flags;
+ using layout::HeadlessSurfaceCreateInfoEXT::sType;
};
static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<HeadlessSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_IOS_MVK
- struct IOSSurfaceCreateInfoMVK
+
+ namespace layout
{
- IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(),
- const void* pView_ = nullptr )
- : flags( flags_ )
- , pView( pView_ )
+ struct IOSSurfaceCreateInfoMVK
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(),
+ const void* pView_ = nullptr )
+ : flags( flags_ )
+ , pView( pView_ )
+ {}
+
+ IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
+ {
+ *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
+ }
+
+ IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
+ {
+ *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
+ const void* pNext = nullptr;
+ vk::IOSSurfaceCreateFlagsMVK flags;
+ const void* pView;
+ };
+ static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" );
+ }
+
+ struct IOSSurfaceCreateInfoMVK : public layout::IOSSurfaceCreateInfoMVK
+ {
+ VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(),
+ const void* pView_ = nullptr )
+ : layout::IOSSurfaceCreateInfoMVK( flags_, pView_ )
{}
IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
- {
- memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
- }
+ : layout::IOSSurfaceCreateInfoMVK( rhs )
+ {}
IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
+ layout::IOSSurfaceCreateInfoMVK::operator=(rhs);
return *this;
}
@@ -31669,7 +38221,7 @@
return *this;
}
- IOSSurfaceCreateInfoMVK & setFlags( IOSSurfaceCreateFlagsMVK flags_ )
+ IOSSurfaceCreateInfoMVK & setFlags( vk::IOSSurfaceCreateFlagsMVK flags_ )
{
flags = flags_;
return *this;
@@ -31705,61 +38257,59 @@
}
private:
- StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
-
- public:
- const void* pNext = nullptr;
- IOSSurfaceCreateFlagsMVK flags;
- const void* pView;
+ using layout::IOSSurfaceCreateInfoMVK::sType;
};
static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<IOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_IOS_MVK*/
struct ImageBlit
{
- ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
- std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D() } },
- ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
- std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D() } } )
+ VULKAN_HPP_CONSTEXPR_14 ImageBlit( vk::ImageSubresourceLayers srcSubresource_ = vk::ImageSubresourceLayers(),
+ std::array<vk::Offset3D,2> const& srcOffsets_ = { { vk::Offset3D() } },
+ vk::ImageSubresourceLayers dstSubresource_ = vk::ImageSubresourceLayers(),
+ std::array<vk::Offset3D,2> const& dstOffsets_ = { { vk::Offset3D() } } )
: srcSubresource( srcSubresource_ )
+ , srcOffsets{}
, dstSubresource( dstSubresource_ )
+ , dstOffsets{}
{
- memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
- memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ vk::ConstExpressionArrayCopy<vk::Offset3D,2,2>::copy( srcOffsets, srcOffsets_ );
+ vk::ConstExpressionArrayCopy<vk::Offset3D,2,2>::copy( dstOffsets, dstOffsets_ );
}
ImageBlit( VkImageBlit const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageBlit ) );
+ *reinterpret_cast<VkImageBlit*>(this) = rhs;
}
ImageBlit& operator=( VkImageBlit const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageBlit ) );
+ *reinterpret_cast<VkImageBlit*>(this) = rhs;
return *this;
}
- ImageBlit & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ ImageBlit & setSrcSubresource( vk::ImageSubresourceLayers srcSubresource_ )
{
srcSubresource = srcSubresource_;
return *this;
}
- ImageBlit & setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
+ ImageBlit & setSrcOffsets( std::array<vk::Offset3D,2> srcOffsets_ )
{
- memcpy( srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
+ memcpy( srcOffsets, srcOffsets_.data(), 2 * sizeof( vk::Offset3D ) );
return *this;
}
- ImageBlit & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ ImageBlit & setDstSubresource( vk::ImageSubresourceLayers dstSubresource_ )
{
dstSubresource = dstSubresource_;
return *this;
}
- ImageBlit & setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
+ ImageBlit & setDstOffsets( std::array<vk::Offset3D,2> dstOffsets_ )
{
- memcpy( dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
+ memcpy( dstOffsets, dstOffsets_.data(), 2 * sizeof( vk::Offset3D ) );
return *this;
}
@@ -31776,9 +38326,9 @@
bool operator==( ImageBlit const& rhs ) const
{
return ( srcSubresource == rhs.srcSubresource )
- && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
+ && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( vk::Offset3D ) ) == 0 )
&& ( dstSubresource == rhs.dstSubresource )
- && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
+ && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( vk::Offset3D ) ) == 0 );
}
bool operator!=( ImageBlit const& rhs ) const
@@ -31786,20 +38336,22 @@
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffsets[2];
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffsets[2];
+ public:
+ vk::ImageSubresourceLayers srcSubresource;
+ vk::Offset3D srcOffsets[2];
+ vk::ImageSubresourceLayers dstSubresource;
+ vk::Offset3D dstOffsets[2];
};
static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageBlit>::value, "struct wrapper is not a standard layout!" );
struct ImageCopy
{
- ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
- Offset3D srcOffset_ = Offset3D(),
- ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
- Offset3D dstOffset_ = Offset3D(),
- Extent3D extent_ = Extent3D() )
+ VULKAN_HPP_CONSTEXPR ImageCopy( vk::ImageSubresourceLayers srcSubresource_ = vk::ImageSubresourceLayers(),
+ vk::Offset3D srcOffset_ = vk::Offset3D(),
+ vk::ImageSubresourceLayers dstSubresource_ = vk::ImageSubresourceLayers(),
+ vk::Offset3D dstOffset_ = vk::Offset3D(),
+ vk::Extent3D extent_ = vk::Extent3D() )
: srcSubresource( srcSubresource_ )
, srcOffset( srcOffset_ )
, dstSubresource( dstSubresource_ )
@@ -31809,40 +38361,40 @@
ImageCopy( VkImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageCopy ) );
+ *reinterpret_cast<VkImageCopy*>(this) = rhs;
}
ImageCopy& operator=( VkImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageCopy ) );
+ *reinterpret_cast<VkImageCopy*>(this) = rhs;
return *this;
}
- ImageCopy & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ ImageCopy & setSrcSubresource( vk::ImageSubresourceLayers srcSubresource_ )
{
srcSubresource = srcSubresource_;
return *this;
}
- ImageCopy & setSrcOffset( Offset3D srcOffset_ )
+ ImageCopy & setSrcOffset( vk::Offset3D srcOffset_ )
{
srcOffset = srcOffset_;
return *this;
}
- ImageCopy & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ ImageCopy & setDstSubresource( vk::ImageSubresourceLayers dstSubresource_ )
{
dstSubresource = dstSubresource_;
return *this;
}
- ImageCopy & setDstOffset( Offset3D dstOffset_ )
+ ImageCopy & setDstOffset( vk::Offset3D dstOffset_ )
{
dstOffset = dstOffset_;
return *this;
}
- ImageCopy & setExtent( Extent3D extent_ )
+ ImageCopy & setExtent( vk::Extent3D extent_ )
{
extent = extent_;
return *this;
@@ -31872,52 +38424,105 @@
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffset;
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffset;
- Extent3D extent;
+ public:
+ vk::ImageSubresourceLayers srcSubresource;
+ vk::Offset3D srcOffset;
+ vk::ImageSubresourceLayers dstSubresource;
+ vk::Offset3D dstOffset;
+ vk::Extent3D extent;
};
static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageCopy>::value, "struct wrapper is not a standard layout!" );
- struct ImageCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , imageType( imageType_ )
- , format( format_ )
- , extent( extent_ )
- , mipLevels( mipLevels_ )
- , arrayLayers( arrayLayers_ )
- , samples( samples_ )
- , tiling( tiling_ )
- , usage( usage_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
- , initialLayout( initialLayout_ )
+ struct ImageCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+ vk::ImageType imageType_ = vk::ImageType::e1D,
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::Extent3D extent_ = vk::Extent3D(),
+ uint32_t mipLevels_ = 0,
+ uint32_t arrayLayers_ = 0,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr,
+ vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined )
+ : flags( flags_ )
+ , imageType( imageType_ )
+ , format( format_ )
+ , extent( extent_ )
+ , mipLevels( mipLevels_ )
+ , arrayLayers( arrayLayers_ )
+ , samples( samples_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , initialLayout( initialLayout_ )
+ {}
+
+ ImageCreateInfo( VkImageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkImageCreateInfo*>(this) = rhs;
+ }
+
+ ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkImageCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageCreateInfo;
+ const void* pNext = nullptr;
+ vk::ImageCreateFlags flags;
+ vk::ImageType imageType;
+ vk::Format format;
+ vk::Extent3D extent;
+ uint32_t mipLevels;
+ uint32_t arrayLayers;
+ vk::SampleCountFlagBits samples;
+ vk::ImageTiling tiling;
+ vk::ImageUsageFlags usage;
+ vk::SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ vk::ImageLayout initialLayout;
+ };
+ static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageCreateInfo : public layout::ImageCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(),
+ vk::ImageType imageType_ = vk::ImageType::e1D,
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::Extent3D extent_ = vk::Extent3D(),
+ uint32_t mipLevels_ = 0,
+ uint32_t arrayLayers_ = 0,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr,
+ vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined )
+ : layout::ImageCreateInfo( flags_, imageType_, format_, extent_, mipLevels_, arrayLayers_, samples_, tiling_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, initialLayout_ )
{}
ImageCreateInfo( VkImageCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
- }
+ : layout::ImageCreateInfo( rhs )
+ {}
ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
+ layout::ImageCreateInfo::operator=(rhs);
return *this;
}
@@ -31927,25 +38532,25 @@
return *this;
}
- ImageCreateInfo & setFlags( ImageCreateFlags flags_ )
+ ImageCreateInfo & setFlags( vk::ImageCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- ImageCreateInfo & setImageType( ImageType imageType_ )
+ ImageCreateInfo & setImageType( vk::ImageType imageType_ )
{
imageType = imageType_;
return *this;
}
- ImageCreateInfo & setFormat( Format format_ )
+ ImageCreateInfo & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- ImageCreateInfo & setExtent( Extent3D extent_ )
+ ImageCreateInfo & setExtent( vk::Extent3D extent_ )
{
extent = extent_;
return *this;
@@ -31963,25 +38568,25 @@
return *this;
}
- ImageCreateInfo & setSamples( SampleCountFlagBits samples_ )
+ ImageCreateInfo & setSamples( vk::SampleCountFlagBits samples_ )
{
samples = samples_;
return *this;
}
- ImageCreateInfo & setTiling( ImageTiling tiling_ )
+ ImageCreateInfo & setTiling( vk::ImageTiling tiling_ )
{
tiling = tiling_;
return *this;
}
- ImageCreateInfo & setUsage( ImageUsageFlags usage_ )
+ ImageCreateInfo & setUsage( vk::ImageUsageFlags usage_ )
{
usage = usage_;
return *this;
}
- ImageCreateInfo & setSharingMode( SharingMode sharingMode_ )
+ ImageCreateInfo & setSharingMode( vk::SharingMode sharingMode_ )
{
sharingMode = sharingMode_;
return *this;
@@ -31999,7 +38604,7 @@
return *this;
}
- ImageCreateInfo & setInitialLayout( ImageLayout initialLayout_ )
+ ImageCreateInfo & setInitialLayout( vk::ImageLayout initialLayout_ )
{
initialLayout = initialLayout_;
return *this;
@@ -32040,28 +38645,27 @@
}
private:
- StructureType sType = StructureType::eImageCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ImageCreateFlags flags;
- ImageType imageType;
- Format format;
- Extent3D extent;
- uint32_t mipLevels;
- uint32_t arrayLayers;
- SampleCountFlagBits samples;
- ImageTiling tiling;
- ImageUsageFlags usage;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- ImageLayout initialLayout;
+ using layout::ImageCreateInfo::sType;
};
static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct SubresourceLayout
{
+ SubresourceLayout()
+ {}
+
+ SubresourceLayout( VkSubresourceLayout const & rhs )
+ {
+ *reinterpret_cast<VkSubresourceLayout*>(this) = rhs;
+ }
+
+ SubresourceLayout& operator=( VkSubresourceLayout const & rhs )
+ {
+ *reinterpret_cast<VkSubresourceLayout*>(this) = rhs;
+ return *this;
+ }
+
operator VkSubresourceLayout const&() const
{
return *reinterpret_cast<const VkSubresourceLayout*>( this );
@@ -32086,32 +38690,65 @@
return !operator==( rhs );
}
- DeviceSize offset;
- DeviceSize size;
- DeviceSize rowPitch;
- DeviceSize arrayPitch;
- DeviceSize depthPitch;
+ public:
+ vk::DeviceSize offset;
+ vk::DeviceSize size;
+ vk::DeviceSize rowPitch;
+ vk::DeviceSize arrayPitch;
+ vk::DeviceSize depthPitch;
};
static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubresourceLayout>::value, "struct wrapper is not a standard layout!" );
- struct ImageDrmFormatModifierExplicitCreateInfoEXT
+ namespace layout
{
- ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
- uint32_t drmFormatModifierPlaneCount_ = 0,
- const SubresourceLayout* pPlaneLayouts_ = nullptr )
- : drmFormatModifier( drmFormatModifier_ )
- , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
- , pPlaneLayouts( pPlaneLayouts_ )
+ struct ImageDrmFormatModifierExplicitCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
+ uint32_t drmFormatModifierPlaneCount_ = 0,
+ const vk::SubresourceLayout* pPlaneLayouts_ = nullptr )
+ : drmFormatModifier( drmFormatModifier_ )
+ , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
+ , pPlaneLayouts( pPlaneLayouts_ )
+ {}
+
+ ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
+ }
+
+ ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
+ const void* pNext = nullptr;
+ uint64_t drmFormatModifier;
+ uint32_t drmFormatModifierPlaneCount;
+ const vk::SubresourceLayout* pPlaneLayouts;
+ };
+ static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageDrmFormatModifierExplicitCreateInfoEXT : public layout::ImageDrmFormatModifierExplicitCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0,
+ uint32_t drmFormatModifierPlaneCount_ = 0,
+ const vk::SubresourceLayout* pPlaneLayouts_ = nullptr )
+ : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( drmFormatModifier_, drmFormatModifierPlaneCount_, pPlaneLayouts_ )
{}
ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
- }
+ : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( rhs )
+ {}
ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
+ layout::ImageDrmFormatModifierExplicitCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -32133,7 +38770,7 @@
return *this;
}
- ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const SubresourceLayout* pPlaneLayouts_ )
+ ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const vk::SubresourceLayout* pPlaneLayouts_ )
{
pPlaneLayouts = pPlaneLayouts_;
return *this;
@@ -32164,32 +38801,56 @@
}
private:
- StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint64_t drmFormatModifier;
- uint32_t drmFormatModifierPlaneCount;
- const SubresourceLayout* pPlaneLayouts;
+ using layout::ImageDrmFormatModifierExplicitCreateInfoEXT::sType;
};
static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageDrmFormatModifierExplicitCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct ImageDrmFormatModifierListCreateInfoEXT
+ namespace layout
{
- ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
- const uint64_t* pDrmFormatModifiers_ = nullptr )
- : drmFormatModifierCount( drmFormatModifierCount_ )
- , pDrmFormatModifiers( pDrmFormatModifiers_ )
+ struct ImageDrmFormatModifierListCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
+ const uint64_t* pDrmFormatModifiers_ = nullptr )
+ : drmFormatModifierCount( drmFormatModifierCount_ )
+ , pDrmFormatModifiers( pDrmFormatModifiers_ )
+ {}
+
+ ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
+ }
+
+ ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
+ const void* pNext = nullptr;
+ uint32_t drmFormatModifierCount;
+ const uint64_t* pDrmFormatModifiers;
+ };
+ static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageDrmFormatModifierListCreateInfoEXT : public layout::ImageDrmFormatModifierListCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0,
+ const uint64_t* pDrmFormatModifiers_ = nullptr )
+ : layout::ImageDrmFormatModifierListCreateInfoEXT( drmFormatModifierCount_, pDrmFormatModifiers_ )
{}
ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
- }
+ : layout::ImageDrmFormatModifierListCreateInfoEXT( rhs )
+ {}
ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
+ layout::ImageDrmFormatModifierListCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -32235,17 +38896,54 @@
}
private:
- StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t drmFormatModifierCount;
- const uint64_t* pDrmFormatModifiers;
+ using layout::ImageDrmFormatModifierListCreateInfoEXT::sType;
};
static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageDrmFormatModifierListCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct ImageDrmFormatModifierPropertiesEXT
+ namespace layout
{
+ struct ImageDrmFormatModifierPropertiesEXT
+ {
+ protected:
+ ImageDrmFormatModifierPropertiesEXT()
+ {}
+
+ ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this) = rhs;
+ }
+
+ ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
+ void* pNext = nullptr;
+ uint64_t drmFormatModifier;
+ };
+ static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageDrmFormatModifierPropertiesEXT : public layout::ImageDrmFormatModifierPropertiesEXT
+ {
+ ImageDrmFormatModifierPropertiesEXT()
+ : layout::ImageDrmFormatModifierPropertiesEXT()
+ {}
+
+ ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs )
+ : layout::ImageDrmFormatModifierPropertiesEXT( rhs )
+ {}
+
+ ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs )
+ {
+ layout::ImageDrmFormatModifierPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkImageDrmFormatModifierPropertiesEXT const&() const
{
return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>( this );
@@ -32269,30 +38967,56 @@
}
private:
- StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint64_t drmFormatModifier;
+ using layout::ImageDrmFormatModifierPropertiesEXT::sType;
};
static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageDrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct ImageFormatListCreateInfoKHR
+ namespace layout
{
- ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
- const Format* pViewFormats_ = nullptr )
- : viewFormatCount( viewFormatCount_ )
- , pViewFormats( pViewFormats_ )
+ struct ImageFormatListCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
+ const vk::Format* pViewFormats_ = nullptr )
+ : viewFormatCount( viewFormatCount_ )
+ , pViewFormats( pViewFormats_ )
+ {}
+
+ ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
+ }
+
+ ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t viewFormatCount;
+ const vk::Format* pViewFormats;
+ };
+ static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageFormatListCreateInfoKHR : public layout::ImageFormatListCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0,
+ const vk::Format* pViewFormats_ = nullptr )
+ : layout::ImageFormatListCreateInfoKHR( viewFormatCount_, pViewFormats_ )
{}
ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
- }
+ : layout::ImageFormatListCreateInfoKHR( rhs )
+ {}
ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
+ layout::ImageFormatListCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -32308,7 +39032,7 @@
return *this;
}
- ImageFormatListCreateInfoKHR & setPViewFormats( const Format* pViewFormats_ )
+ ImageFormatListCreateInfoKHR & setPViewFormats( const vk::Format* pViewFormats_ )
{
pViewFormats = pViewFormats_;
return *this;
@@ -32338,17 +39062,54 @@
}
private:
- StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t viewFormatCount;
- const Format* pViewFormats;
+ using layout::ImageFormatListCreateInfoKHR::sType;
};
static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageFormatListCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct ImageFormatProperties2
+ namespace layout
{
+ struct ImageFormatProperties2
+ {
+ protected:
+ ImageFormatProperties2()
+ {}
+
+ ImageFormatProperties2( VkImageFormatProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkImageFormatProperties2*>(this) = rhs;
+ }
+
+ ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkImageFormatProperties2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageFormatProperties2;
+ void* pNext = nullptr;
+ vk::ImageFormatProperties imageFormatProperties;
+ };
+ static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageFormatProperties2 : public layout::ImageFormatProperties2
+ {
+ ImageFormatProperties2()
+ : layout::ImageFormatProperties2()
+ {}
+
+ ImageFormatProperties2( VkImageFormatProperties2 const & rhs )
+ : layout::ImageFormatProperties2( rhs )
+ {}
+
+ ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs )
+ {
+ layout::ImageFormatProperties2::operator=(rhs);
+ return *this;
+ }
+
operator VkImageFormatProperties2 const&() const
{
return *reinterpret_cast<const VkImageFormatProperties2*>( this );
@@ -32372,21 +39133,18 @@
}
private:
- StructureType sType = StructureType::eImageFormatProperties2;
-
- public:
- void* pNext = nullptr;
- ImageFormatProperties imageFormatProperties;
+ using layout::ImageFormatProperties2::sType;
};
static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
struct ImageSubresourceRange
{
- ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(),
- uint32_t baseMipLevel_ = 0,
- uint32_t levelCount_ = 0,
- uint32_t baseArrayLayer_ = 0,
- uint32_t layerCount_ = 0 )
+ VULKAN_HPP_CONSTEXPR ImageSubresourceRange( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(),
+ uint32_t baseMipLevel_ = 0,
+ uint32_t levelCount_ = 0,
+ uint32_t baseArrayLayer_ = 0,
+ uint32_t layerCount_ = 0 )
: aspectMask( aspectMask_ )
, baseMipLevel( baseMipLevel_ )
, levelCount( levelCount_ )
@@ -32396,16 +39154,16 @@
ImageSubresourceRange( VkImageSubresourceRange const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+ *reinterpret_cast<VkImageSubresourceRange*>(this) = rhs;
}
ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
+ *reinterpret_cast<VkImageSubresourceRange*>(this) = rhs;
return *this;
}
- ImageSubresourceRange & setAspectMask( ImageAspectFlags aspectMask_ )
+ ImageSubresourceRange & setAspectMask( vk::ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
return *this;
@@ -32459,42 +39217,85 @@
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
+ public:
+ vk::ImageAspectFlags aspectMask;
uint32_t baseMipLevel;
uint32_t levelCount;
uint32_t baseArrayLayer;
uint32_t layerCount;
};
static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageSubresourceRange>::value, "struct wrapper is not a standard layout!" );
- struct ImageMemoryBarrier
+ namespace layout
{
- 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() )
- : srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , oldLayout( oldLayout_ )
- , newLayout( newLayout_ )
- , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
- , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
- , image( image_ )
- , subresourceRange( subresourceRange_ )
+ struct ImageMemoryBarrier
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ vk::ImageLayout oldLayout_ = vk::ImageLayout::eUndefined,
+ vk::ImageLayout newLayout_ = vk::ImageLayout::eUndefined,
+ uint32_t srcQueueFamilyIndex_ = 0,
+ uint32_t dstQueueFamilyIndex_ = 0,
+ vk::Image image_ = vk::Image(),
+ vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+ : srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , oldLayout( oldLayout_ )
+ , newLayout( newLayout_ )
+ , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
+ , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
+ , image( image_ )
+ , subresourceRange( subresourceRange_ )
+ {}
+
+ ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
+ {
+ *reinterpret_cast<VkImageMemoryBarrier*>(this) = rhs;
+ }
+
+ ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
+ {
+ *reinterpret_cast<VkImageMemoryBarrier*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageMemoryBarrier;
+ const void* pNext = nullptr;
+ vk::AccessFlags srcAccessMask;
+ vk::AccessFlags dstAccessMask;
+ vk::ImageLayout oldLayout;
+ vk::ImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ vk::Image image;
+ vk::ImageSubresourceRange subresourceRange;
+ };
+ static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageMemoryBarrier : public layout::ImageMemoryBarrier
+ {
+ VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ vk::ImageLayout oldLayout_ = vk::ImageLayout::eUndefined,
+ vk::ImageLayout newLayout_ = vk::ImageLayout::eUndefined,
+ uint32_t srcQueueFamilyIndex_ = 0,
+ uint32_t dstQueueFamilyIndex_ = 0,
+ vk::Image image_ = vk::Image(),
+ vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+ : layout::ImageMemoryBarrier( srcAccessMask_, dstAccessMask_, oldLayout_, newLayout_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, image_, subresourceRange_ )
{}
ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
- }
+ : layout::ImageMemoryBarrier( rhs )
+ {}
ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
+ layout::ImageMemoryBarrier::operator=(rhs);
return *this;
}
@@ -32504,25 +39305,25 @@
return *this;
}
- ImageMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+ ImageMemoryBarrier & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
{
srcAccessMask = srcAccessMask_;
return *this;
}
- ImageMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+ ImageMemoryBarrier & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
{
dstAccessMask = dstAccessMask_;
return *this;
}
- ImageMemoryBarrier & setOldLayout( ImageLayout oldLayout_ )
+ ImageMemoryBarrier & setOldLayout( vk::ImageLayout oldLayout_ )
{
oldLayout = oldLayout_;
return *this;
}
- ImageMemoryBarrier & setNewLayout( ImageLayout newLayout_ )
+ ImageMemoryBarrier & setNewLayout( vk::ImageLayout newLayout_ )
{
newLayout = newLayout_;
return *this;
@@ -32540,13 +39341,13 @@
return *this;
}
- ImageMemoryBarrier & setImage( Image image_ )
+ ImageMemoryBarrier & setImage( vk::Image image_ )
{
image = image_;
return *this;
}
- ImageMemoryBarrier & setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ ImageMemoryBarrier & setSubresourceRange( vk::ImageSubresourceRange subresourceRange_ )
{
subresourceRange = subresourceRange_;
return *this;
@@ -32582,35 +39383,52 @@
}
private:
- StructureType sType = StructureType::eImageMemoryBarrier;
-
- public:
- const void* pNext = nullptr;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- ImageLayout oldLayout;
- ImageLayout newLayout;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- Image image;
- ImageSubresourceRange subresourceRange;
+ using layout::ImageMemoryBarrier::sType;
};
static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageMemoryBarrier>::value, "struct wrapper is not a standard layout!" );
- struct ImageMemoryRequirementsInfo2
+ namespace layout
{
- ImageMemoryRequirementsInfo2( Image image_ = Image() )
- : image( image_ )
+ struct ImageMemoryRequirementsInfo2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+ : image( image_ )
+ {}
+
+ ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
+ }
+
+ ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
+ const void* pNext = nullptr;
+ vk::Image image;
+ };
+ static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageMemoryRequirementsInfo2 : public layout::ImageMemoryRequirementsInfo2
+ {
+ VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+ : layout::ImageMemoryRequirementsInfo2( image_ )
{}
ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
- }
+ : layout::ImageMemoryRequirementsInfo2( rhs )
+ {}
ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
+ layout::ImageMemoryRequirementsInfo2::operator=(rhs);
return *this;
}
@@ -32620,7 +39438,7 @@
return *this;
}
- ImageMemoryRequirementsInfo2 & setImage( Image image_ )
+ ImageMemoryRequirementsInfo2 & setImage( vk::Image image_ )
{
image = image_;
return *this;
@@ -32649,31 +39467,58 @@
}
private:
- StructureType sType = StructureType::eImageMemoryRequirementsInfo2;
-
- public:
- const void* pNext = nullptr;
- Image image;
+ using layout::ImageMemoryRequirementsInfo2::sType;
};
static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_FUCHSIA
- struct ImagePipeSurfaceCreateInfoFUCHSIA
+
+ namespace layout
{
- ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(),
- zx_handle_t imagePipeHandle_ = 0 )
- : flags( flags_ )
- , imagePipeHandle( imagePipeHandle_ )
+ struct ImagePipeSurfaceCreateInfoFUCHSIA
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(),
+ zx_handle_t imagePipeHandle_ = 0 )
+ : flags( flags_ )
+ , imagePipeHandle( imagePipeHandle_ )
+ {}
+
+ ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+ {
+ *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
+ }
+
+ ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
+ {
+ *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
+ const void* pNext = nullptr;
+ vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags;
+ zx_handle_t imagePipeHandle;
+ };
+ static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImagePipeSurfaceCreateInfoFUCHSIA : public layout::ImagePipeSurfaceCreateInfoFUCHSIA
+ {
+ VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(),
+ zx_handle_t imagePipeHandle_ = 0 )
+ : layout::ImagePipeSurfaceCreateInfoFUCHSIA( flags_, imagePipeHandle_ )
{}
ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
- }
+ : layout::ImagePipeSurfaceCreateInfoFUCHSIA( rhs )
+ {}
ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
{
- memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
+ layout::ImagePipeSurfaceCreateInfoFUCHSIA::operator=(rhs);
return *this;
}
@@ -32683,7 +39528,7 @@
return *this;
}
- ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
+ ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
{
flags = flags_;
return *this;
@@ -32719,30 +39564,53 @@
}
private:
- StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA;
-
- public:
- const void* pNext = nullptr;
- ImagePipeSurfaceCreateFlagsFUCHSIA flags;
- zx_handle_t imagePipeHandle;
+ using layout::ImagePipeSurfaceCreateInfoFUCHSIA::sType;
};
static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImagePipeSurfaceCreateInfoFUCHSIA>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
- struct ImagePlaneMemoryRequirementsInfo
+ namespace layout
{
- ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
- : planeAspect( planeAspect_ )
+ struct ImagePlaneMemoryRequirementsInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+ : planeAspect( planeAspect_ )
+ {}
+
+ ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
+ {
+ *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
+ }
+
+ ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
+ {
+ *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
+ const void* pNext = nullptr;
+ vk::ImageAspectFlagBits planeAspect;
+ };
+ static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImagePlaneMemoryRequirementsInfo : public layout::ImagePlaneMemoryRequirementsInfo
+ {
+ VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor )
+ : layout::ImagePlaneMemoryRequirementsInfo( planeAspect_ )
{}
ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
- }
+ : layout::ImagePlaneMemoryRequirementsInfo( rhs )
+ {}
ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
+ layout::ImagePlaneMemoryRequirementsInfo::operator=(rhs);
return *this;
}
@@ -32752,7 +39620,7 @@
return *this;
}
- ImagePlaneMemoryRequirementsInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ )
+ ImagePlaneMemoryRequirementsInfo & setPlaneAspect( vk::ImageAspectFlagBits planeAspect_ )
{
planeAspect = planeAspect_;
return *this;
@@ -32781,21 +39649,18 @@
}
private:
- StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo;
-
- public:
- const void* pNext = nullptr;
- ImageAspectFlagBits planeAspect;
+ using layout::ImagePlaneMemoryRequirementsInfo::sType;
};
static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImagePlaneMemoryRequirementsInfo>::value, "struct wrapper is not a standard layout!" );
struct ImageResolve
{
- ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(),
- Offset3D srcOffset_ = Offset3D(),
- ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(),
- Offset3D dstOffset_ = Offset3D(),
- Extent3D extent_ = Extent3D() )
+ VULKAN_HPP_CONSTEXPR ImageResolve( vk::ImageSubresourceLayers srcSubresource_ = vk::ImageSubresourceLayers(),
+ vk::Offset3D srcOffset_ = vk::Offset3D(),
+ vk::ImageSubresourceLayers dstSubresource_ = vk::ImageSubresourceLayers(),
+ vk::Offset3D dstOffset_ = vk::Offset3D(),
+ vk::Extent3D extent_ = vk::Extent3D() )
: srcSubresource( srcSubresource_ )
, srcOffset( srcOffset_ )
, dstSubresource( dstSubresource_ )
@@ -32805,40 +39670,40 @@
ImageResolve( VkImageResolve const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageResolve ) );
+ *reinterpret_cast<VkImageResolve*>(this) = rhs;
}
ImageResolve& operator=( VkImageResolve const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageResolve ) );
+ *reinterpret_cast<VkImageResolve*>(this) = rhs;
return *this;
}
- ImageResolve & setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
+ ImageResolve & setSrcSubresource( vk::ImageSubresourceLayers srcSubresource_ )
{
srcSubresource = srcSubresource_;
return *this;
}
- ImageResolve & setSrcOffset( Offset3D srcOffset_ )
+ ImageResolve & setSrcOffset( vk::Offset3D srcOffset_ )
{
srcOffset = srcOffset_;
return *this;
}
- ImageResolve & setDstSubresource( ImageSubresourceLayers dstSubresource_ )
+ ImageResolve & setDstSubresource( vk::ImageSubresourceLayers dstSubresource_ )
{
dstSubresource = dstSubresource_;
return *this;
}
- ImageResolve & setDstOffset( Offset3D dstOffset_ )
+ ImageResolve & setDstOffset( vk::Offset3D dstOffset_ )
{
dstOffset = dstOffset_;
return *this;
}
- ImageResolve & setExtent( Extent3D extent_ )
+ ImageResolve & setExtent( vk::Extent3D extent_ )
{
extent = extent_;
return *this;
@@ -32868,28 +39733,57 @@
return !operator==( rhs );
}
- ImageSubresourceLayers srcSubresource;
- Offset3D srcOffset;
- ImageSubresourceLayers dstSubresource;
- Offset3D dstOffset;
- Extent3D extent;
+ public:
+ vk::ImageSubresourceLayers srcSubresource;
+ vk::Offset3D srcOffset;
+ vk::ImageSubresourceLayers dstSubresource;
+ vk::Offset3D dstOffset;
+ vk::Extent3D extent;
};
static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageResolve>::value, "struct wrapper is not a standard layout!" );
- struct ImageSparseMemoryRequirementsInfo2
+ namespace layout
{
- ImageSparseMemoryRequirementsInfo2( Image image_ = Image() )
- : image( image_ )
+ struct ImageSparseMemoryRequirementsInfo2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+ : image( image_ )
+ {}
+
+ ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
+ }
+
+ ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
+ const void* pNext = nullptr;
+ vk::Image image;
+ };
+ static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageSparseMemoryRequirementsInfo2 : public layout::ImageSparseMemoryRequirementsInfo2
+ {
+ VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() )
+ : layout::ImageSparseMemoryRequirementsInfo2( image_ )
{}
ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
- }
+ : layout::ImageSparseMemoryRequirementsInfo2( rhs )
+ {}
ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
+ layout::ImageSparseMemoryRequirementsInfo2::operator=(rhs);
return *this;
}
@@ -32899,7 +39793,7 @@
return *this;
}
- ImageSparseMemoryRequirementsInfo2 & setImage( Image image_ )
+ ImageSparseMemoryRequirementsInfo2 & setImage( vk::Image image_ )
{
image = image_;
return *this;
@@ -32928,28 +39822,52 @@
}
private:
- StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2;
-
- public:
- const void* pNext = nullptr;
- Image image;
+ using layout::ImageSparseMemoryRequirementsInfo2::sType;
};
static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageSparseMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" );
- struct ImageStencilUsageCreateInfoEXT
+ namespace layout
{
- ImageStencilUsageCreateInfoEXT( ImageUsageFlags stencilUsage_ = ImageUsageFlags() )
- : stencilUsage( stencilUsage_ )
+ struct ImageStencilUsageCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() )
+ : stencilUsage( stencilUsage_ )
+ {}
+
+ ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
+ }
+
+ ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::ImageUsageFlags stencilUsage;
+ };
+ static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageStencilUsageCreateInfoEXT : public layout::ImageStencilUsageCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() )
+ : layout::ImageStencilUsageCreateInfoEXT( stencilUsage_ )
{}
ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) );
- }
+ : layout::ImageStencilUsageCreateInfoEXT( rhs )
+ {}
ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageStencilUsageCreateInfoEXT ) );
+ layout::ImageStencilUsageCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -32959,7 +39877,7 @@
return *this;
}
- ImageStencilUsageCreateInfoEXT & setStencilUsage( ImageUsageFlags stencilUsage_ )
+ ImageStencilUsageCreateInfoEXT & setStencilUsage( vk::ImageUsageFlags stencilUsage_ )
{
stencilUsage = stencilUsage_;
return *this;
@@ -32988,28 +39906,52 @@
}
private:
- StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- ImageUsageFlags stencilUsage;
+ using layout::ImageStencilUsageCreateInfoEXT::sType;
};
static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageStencilUsageCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct ImageSwapchainCreateInfoKHR
+ namespace layout
{
- ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = SwapchainKHR() )
- : swapchain( swapchain_ )
+ struct ImageSwapchainCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() )
+ : swapchain( swapchain_ )
+ {}
+
+ ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
+ }
+
+ ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::SwapchainKHR swapchain;
+ };
+ static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageSwapchainCreateInfoKHR : public layout::ImageSwapchainCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() )
+ : layout::ImageSwapchainCreateInfoKHR( swapchain_ )
{}
ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
- }
+ : layout::ImageSwapchainCreateInfoKHR( rhs )
+ {}
ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
+ layout::ImageSwapchainCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -33019,7 +39961,7 @@
return *this;
}
- ImageSwapchainCreateInfoKHR & setSwapchain( SwapchainKHR swapchain_ )
+ ImageSwapchainCreateInfoKHR & setSwapchain( vk::SwapchainKHR swapchain_ )
{
swapchain = swapchain_;
return *this;
@@ -33048,28 +39990,52 @@
}
private:
- StructureType sType = StructureType::eImageSwapchainCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- SwapchainKHR swapchain;
+ using layout::ImageSwapchainCreateInfoKHR::sType;
};
static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct ImageViewASTCDecodeModeEXT
+ namespace layout
{
- ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined )
- : decodeMode( decodeMode_ )
+ struct ImageViewASTCDecodeModeEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined )
+ : decodeMode( decodeMode_ )
+ {}
+
+ ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
+ }
+
+ ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
+ {
+ *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
+ const void* pNext = nullptr;
+ vk::Format decodeMode;
+ };
+ static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageViewASTCDecodeModeEXT : public layout::ImageViewASTCDecodeModeEXT
+ {
+ VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined )
+ : layout::ImageViewASTCDecodeModeEXT( decodeMode_ )
{}
ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
- }
+ : layout::ImageViewASTCDecodeModeEXT( rhs )
+ {}
ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
+ layout::ImageViewASTCDecodeModeEXT::operator=(rhs);
return *this;
}
@@ -33079,7 +40045,7 @@
return *this;
}
- ImageViewASTCDecodeModeEXT & setDecodeMode( Format decodeMode_ )
+ ImageViewASTCDecodeModeEXT & setDecodeMode( vk::Format decodeMode_ )
{
decodeMode = decodeMode_;
return *this;
@@ -33108,38 +40074,72 @@
}
private:
- StructureType sType = StructureType::eImageViewAstcDecodeModeEXT;
-
- public:
- const void* pNext = nullptr;
- Format decodeMode;
+ using layout::ImageViewASTCDecodeModeEXT::sType;
};
static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageViewASTCDecodeModeEXT>::value, "struct wrapper is not a standard layout!" );
- struct ImageViewCreateInfo
+ namespace layout
{
- ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(),
- Image image_ = Image(),
- ImageViewType viewType_ = ImageViewType::e1D,
- Format format_ = Format::eUndefined,
- ComponentMapping components_ = ComponentMapping(),
- ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
- : flags( flags_ )
- , image( image_ )
- , viewType( viewType_ )
- , format( format_ )
- , components( components_ )
- , subresourceRange( subresourceRange_ )
+ struct ImageViewCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(),
+ vk::Image image_ = vk::Image(),
+ vk::ImageViewType viewType_ = vk::ImageViewType::e1D,
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::ComponentMapping components_ = vk::ComponentMapping(),
+ vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+ : flags( flags_ )
+ , image( image_ )
+ , viewType( viewType_ )
+ , format( format_ )
+ , components( components_ )
+ , subresourceRange( subresourceRange_ )
+ {}
+
+ ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkImageViewCreateInfo*>(this) = rhs;
+ }
+
+ ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkImageViewCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageViewCreateInfo;
+ const void* pNext = nullptr;
+ vk::ImageViewCreateFlags flags;
+ vk::Image image;
+ vk::ImageViewType viewType;
+ vk::Format format;
+ vk::ComponentMapping components;
+ vk::ImageSubresourceRange subresourceRange;
+ };
+ static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageViewCreateInfo : public layout::ImageViewCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(),
+ vk::Image image_ = vk::Image(),
+ vk::ImageViewType viewType_ = vk::ImageViewType::e1D,
+ vk::Format format_ = vk::Format::eUndefined,
+ vk::ComponentMapping components_ = vk::ComponentMapping(),
+ vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() )
+ : layout::ImageViewCreateInfo( flags_, image_, viewType_, format_, components_, subresourceRange_ )
{}
ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
- }
+ : layout::ImageViewCreateInfo( rhs )
+ {}
ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
+ layout::ImageViewCreateInfo::operator=(rhs);
return *this;
}
@@ -33149,37 +40149,37 @@
return *this;
}
- ImageViewCreateInfo & setFlags( ImageViewCreateFlags flags_ )
+ ImageViewCreateInfo & setFlags( vk::ImageViewCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- ImageViewCreateInfo & setImage( Image image_ )
+ ImageViewCreateInfo & setImage( vk::Image image_ )
{
image = image_;
return *this;
}
- ImageViewCreateInfo & setViewType( ImageViewType viewType_ )
+ ImageViewCreateInfo & setViewType( vk::ImageViewType viewType_ )
{
viewType = viewType_;
return *this;
}
- ImageViewCreateInfo & setFormat( Format format_ )
+ ImageViewCreateInfo & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- ImageViewCreateInfo & setComponents( ComponentMapping components_ )
+ ImageViewCreateInfo & setComponents( vk::ComponentMapping components_ )
{
components = components_;
return *this;
}
- ImageViewCreateInfo & setSubresourceRange( ImageSubresourceRange subresourceRange_ )
+ ImageViewCreateInfo & setSubresourceRange( vk::ImageSubresourceRange subresourceRange_ )
{
subresourceRange = subresourceRange_;
return *this;
@@ -33213,37 +40213,60 @@
}
private:
- StructureType sType = StructureType::eImageViewCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ImageViewCreateFlags flags;
- Image image;
- ImageViewType viewType;
- Format format;
- ComponentMapping components;
- ImageSubresourceRange subresourceRange;
+ using layout::ImageViewCreateInfo::sType;
};
static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageViewCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ImageViewHandleInfoNVX
+ namespace layout
{
- ImageViewHandleInfoNVX( ImageView imageView_ = ImageView(),
- DescriptorType descriptorType_ = DescriptorType::eSampler,
- Sampler sampler_ = Sampler() )
- : imageView( imageView_ )
- , descriptorType( descriptorType_ )
- , sampler( sampler_ )
+ struct ImageViewHandleInfoNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(),
+ vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+ vk::Sampler sampler_ = vk::Sampler() )
+ : imageView( imageView_ )
+ , descriptorType( descriptorType_ )
+ , sampler( sampler_ )
+ {}
+
+ ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkImageViewHandleInfoNVX*>(this) = rhs;
+ }
+
+ ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkImageViewHandleInfoNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageViewHandleInfoNVX;
+ const void* pNext = nullptr;
+ vk::ImageView imageView;
+ vk::DescriptorType descriptorType;
+ vk::Sampler sampler;
+ };
+ static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageViewHandleInfoNVX : public layout::ImageViewHandleInfoNVX
+ {
+ VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(),
+ vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+ vk::Sampler sampler_ = vk::Sampler() )
+ : layout::ImageViewHandleInfoNVX( imageView_, descriptorType_, sampler_ )
{}
ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageViewHandleInfoNVX ) );
- }
+ : layout::ImageViewHandleInfoNVX( rhs )
+ {}
ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewHandleInfoNVX ) );
+ layout::ImageViewHandleInfoNVX::operator=(rhs);
return *this;
}
@@ -33253,19 +40276,19 @@
return *this;
}
- ImageViewHandleInfoNVX & setImageView( ImageView imageView_ )
+ ImageViewHandleInfoNVX & setImageView( vk::ImageView imageView_ )
{
imageView = imageView_;
return *this;
}
- ImageViewHandleInfoNVX & setDescriptorType( DescriptorType descriptorType_ )
+ ImageViewHandleInfoNVX & setDescriptorType( vk::DescriptorType descriptorType_ )
{
descriptorType = descriptorType_;
return *this;
}
- ImageViewHandleInfoNVX & setSampler( Sampler sampler_ )
+ ImageViewHandleInfoNVX & setSampler( vk::Sampler sampler_ )
{
sampler = sampler_;
return *this;
@@ -33296,30 +40319,52 @@
}
private:
- StructureType sType = StructureType::eImageViewHandleInfoNVX;
-
- public:
- const void* pNext = nullptr;
- ImageView imageView;
- DescriptorType descriptorType;
- Sampler sampler;
+ using layout::ImageViewHandleInfoNVX::sType;
};
static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageViewHandleInfoNVX>::value, "struct wrapper is not a standard layout!" );
- struct ImageViewUsageCreateInfo
+ namespace layout
{
- ImageViewUsageCreateInfo( ImageUsageFlags usage_ = ImageUsageFlags() )
- : usage( usage_ )
+ struct ImageViewUsageCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() )
+ : usage( usage_ )
+ {}
+
+ ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkImageViewUsageCreateInfo*>(this) = rhs;
+ }
+
+ ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkImageViewUsageCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImageViewUsageCreateInfo;
+ const void* pNext = nullptr;
+ vk::ImageUsageFlags usage;
+ };
+ static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImageViewUsageCreateInfo : public layout::ImageViewUsageCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() )
+ : layout::ImageViewUsageCreateInfo( usage_ )
{}
ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
- }
+ : layout::ImageViewUsageCreateInfo( rhs )
+ {}
ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
+ layout::ImageViewUsageCreateInfo::operator=(rhs);
return *this;
}
@@ -33329,7 +40374,7 @@
return *this;
}
- ImageViewUsageCreateInfo & setUsage( ImageUsageFlags usage_ )
+ ImageViewUsageCreateInfo & setUsage( vk::ImageUsageFlags usage_ )
{
usage = usage_;
return *this;
@@ -33358,29 +40403,54 @@
}
private:
- StructureType sType = StructureType::eImageViewUsageCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ImageUsageFlags usage;
+ using layout::ImageViewUsageCreateInfo::sType;
};
static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImageViewUsageCreateInfo>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct ImportAndroidHardwareBufferInfoANDROID
+
+ namespace layout
{
- ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
- : buffer( buffer_ )
+ struct ImportAndroidHardwareBufferInfoANDROID
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
+ : buffer( buffer_ )
+ {}
+
+ ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
+ {
+ *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+ }
+
+ ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
+ {
+ *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
+ const void* pNext = nullptr;
+ struct AHardwareBuffer* buffer;
+ };
+ static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportAndroidHardwareBufferInfoANDROID : public layout::ImportAndroidHardwareBufferInfoANDROID
+ {
+ VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
+ : layout::ImportAndroidHardwareBufferInfoANDROID( buffer_ )
{}
ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
- }
+ : layout::ImportAndroidHardwareBufferInfoANDROID( rhs )
+ {}
ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
+ layout::ImportAndroidHardwareBufferInfoANDROID::operator=(rhs);
return *this;
}
@@ -33419,35 +40489,65 @@
}
private:
- StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID;
-
- public:
- const void* pNext = nullptr;
- struct AHardwareBuffer* buffer;
+ using layout::ImportAndroidHardwareBufferInfoANDROID::sType;
};
static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- struct ImportFenceFdInfoKHR
+ namespace layout
{
- ImportFenceFdInfoKHR( Fence fence_ = Fence(),
- FenceImportFlags flags_ = FenceImportFlags(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
- int fd_ = 0 )
- : fence( fence_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , fd( fd_ )
+ struct ImportFenceFdInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : fence( fence_ )
+ , flags( flags_ )
+ , handleType( handleType_ )
+ , fd( fd_ )
+ {}
+
+ ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportFenceFdInfoKHR*>(this) = rhs;
+ }
+
+ ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportFenceFdInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportFenceFdInfoKHR;
+ const void* pNext = nullptr;
+ vk::Fence fence;
+ vk::FenceImportFlags flags;
+ vk::ExternalFenceHandleTypeFlagBits handleType;
+ int fd;
+ };
+ static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportFenceFdInfoKHR : public layout::ImportFenceFdInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : layout::ImportFenceFdInfoKHR( fence_, flags_, handleType_, fd_ )
{}
ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
- }
+ : layout::ImportFenceFdInfoKHR( rhs )
+ {}
ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
+ layout::ImportFenceFdInfoKHR::operator=(rhs);
return *this;
}
@@ -33457,19 +40557,19 @@
return *this;
}
- ImportFenceFdInfoKHR & setFence( Fence fence_ )
+ ImportFenceFdInfoKHR & setFence( vk::Fence fence_ )
{
fence = fence_;
return *this;
}
- ImportFenceFdInfoKHR & setFlags( FenceImportFlags flags_ )
+ ImportFenceFdInfoKHR & setFlags( vk::FenceImportFlags flags_ )
{
flags = flags_;
return *this;
}
- ImportFenceFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ ImportFenceFdInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -33507,40 +40607,70 @@
}
private:
- StructureType sType = StructureType::eImportFenceFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- FenceImportFlags flags;
- ExternalFenceHandleTypeFlagBits handleType;
- int fd;
+ using layout::ImportFenceFdInfoKHR::sType;
};
static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportFenceFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportFenceWin32HandleInfoKHR
+
+ namespace layout
{
- ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
- FenceImportFlags flags_ = FenceImportFlags(),
- ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd,
- HANDLE handle_ = 0,
- LPCWSTR name_ = nullptr )
- : fence( fence_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , handle( handle_ )
- , name( name_ )
+ struct ImportFenceWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = nullptr )
+ : fence( fence_ )
+ , flags( flags_ )
+ , handleType( handleType_ )
+ , handle( handle_ )
+ , name( name_ )
+ {}
+
+ ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ vk::Fence fence;
+ vk::FenceImportFlags flags;
+ vk::ExternalFenceHandleTypeFlagBits handleType;
+ HANDLE handle;
+ LPCWSTR name;
+ };
+ static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportFenceWin32HandleInfoKHR : public layout::ImportFenceWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(),
+ vk::FenceImportFlags flags_ = vk::FenceImportFlags(),
+ vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = nullptr )
+ : layout::ImportFenceWin32HandleInfoKHR( fence_, flags_, handleType_, handle_, name_ )
{}
ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
- }
+ : layout::ImportFenceWin32HandleInfoKHR( rhs )
+ {}
ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
+ layout::ImportFenceWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -33550,19 +40680,19 @@
return *this;
}
- ImportFenceWin32HandleInfoKHR & setFence( Fence fence_ )
+ ImportFenceWin32HandleInfoKHR & setFence( vk::Fence fence_ )
{
fence = fence_;
return *this;
}
- ImportFenceWin32HandleInfoKHR & setFlags( FenceImportFlags flags_ )
+ ImportFenceWin32HandleInfoKHR & setFlags( vk::FenceImportFlags flags_ )
{
flags = flags_;
return *this;
}
- ImportFenceWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ ImportFenceWin32HandleInfoKHR & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -33607,35 +40737,57 @@
}
private:
- StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Fence fence;
- FenceImportFlags flags;
- ExternalFenceHandleTypeFlagBits handleType;
- HANDLE handle;
- LPCWSTR name;
+ using layout::ImportFenceWin32HandleInfoKHR::sType;
};
static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct ImportMemoryFdInfoKHR
+ namespace layout
{
- ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
- int fd_ = 0 )
- : handleType( handleType_ )
- , fd( fd_ )
+ struct ImportMemoryFdInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : handleType( handleType_ )
+ , fd( fd_ )
+ {}
+
+ ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this) = rhs;
+ }
+
+ ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ int fd;
+ };
+ static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportMemoryFdInfoKHR : public layout::ImportMemoryFdInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : layout::ImportMemoryFdInfoKHR( handleType_, fd_ )
{}
ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
- }
+ : layout::ImportMemoryFdInfoKHR( rhs )
+ {}
ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
+ layout::ImportMemoryFdInfoKHR::operator=(rhs);
return *this;
}
@@ -33645,7 +40797,7 @@
return *this;
}
- ImportMemoryFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportMemoryFdInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -33681,31 +40833,56 @@
}
private:
- StructureType sType = StructureType::eImportMemoryFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
- int fd;
+ using layout::ImportMemoryFdInfoKHR::sType;
};
static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportMemoryFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct ImportMemoryHostPointerInfoEXT
+ namespace layout
{
- ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
- void* pHostPointer_ = nullptr )
- : handleType( handleType_ )
- , pHostPointer( pHostPointer_ )
+ struct ImportMemoryHostPointerInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ void* pHostPointer_ = nullptr )
+ : handleType( handleType_ )
+ , pHostPointer( pHostPointer_ )
+ {}
+
+ ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
+ }
+
+ ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ void* pHostPointer;
+ };
+ static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportMemoryHostPointerInfoEXT : public layout::ImportMemoryHostPointerInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ void* pHostPointer_ = nullptr )
+ : layout::ImportMemoryHostPointerInfoEXT( handleType_, pHostPointer_ )
{}
ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
- }
+ : layout::ImportMemoryHostPointerInfoEXT( rhs )
+ {}
ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
+ layout::ImportMemoryHostPointerInfoEXT::operator=(rhs);
return *this;
}
@@ -33715,7 +40892,7 @@
return *this;
}
- ImportMemoryHostPointerInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportMemoryHostPointerInfoEXT & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -33751,34 +40928,62 @@
}
private:
- StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
- void* pHostPointer;
+ using layout::ImportMemoryHostPointerInfoEXT::sType;
};
static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportMemoryHostPointerInfoEXT>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportMemoryWin32HandleInfoKHR
+
+ namespace layout
{
- ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
- HANDLE handle_ = 0,
- LPCWSTR name_ = nullptr )
- : handleType( handleType_ )
- , handle( handle_ )
- , name( name_ )
+ struct ImportMemoryWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = nullptr )
+ : handleType( handleType_ )
+ , handle( handle_ )
+ , name( name_ )
+ {}
+
+ ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ HANDLE handle;
+ LPCWSTR name;
+ };
+ static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportMemoryWin32HandleInfoKHR : public layout::ImportMemoryWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = nullptr )
+ : layout::ImportMemoryWin32HandleInfoKHR( handleType_, handle_, name_ )
{}
ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
- }
+ : layout::ImportMemoryWin32HandleInfoKHR( rhs )
+ {}
ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
+ layout::ImportMemoryWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -33788,7 +40993,7 @@
return *this;
}
- ImportMemoryWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ ImportMemoryWin32HandleInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -33831,34 +41036,59 @@
}
private:
- StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
- HANDLE handle;
- LPCWSTR name;
+ using layout::ImportMemoryWin32HandleInfoKHR::sType;
};
static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportMemoryWin32HandleInfoNV
+
+ namespace layout
{
- ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
- HANDLE handle_ = 0 )
- : handleType( handleType_ )
- , handle( handle_ )
+ struct ImportMemoryWin32HandleInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(),
+ HANDLE handle_ = 0 )
+ : handleType( handleType_ )
+ , handle( handle_ )
+ {}
+
+ ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
+ }
+
+ ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagsNV handleType;
+ HANDLE handle;
+ };
+ static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportMemoryWin32HandleInfoNV : public layout::ImportMemoryWin32HandleInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(),
+ HANDLE handle_ = 0 )
+ : layout::ImportMemoryWin32HandleInfoNV( handleType_, handle_ )
{}
ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
- }
+ : layout::ImportMemoryWin32HandleInfoNV( rhs )
+ {}
ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
+ layout::ImportMemoryWin32HandleInfoNV::operator=(rhs);
return *this;
}
@@ -33868,7 +41098,7 @@
return *this;
}
- ImportMemoryWin32HandleInfoNV & setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
+ ImportMemoryWin32HandleInfoNV & setHandleType( vk::ExternalMemoryHandleTypeFlagsNV handleType_ )
{
handleType = handleType_;
return *this;
@@ -33904,36 +41134,65 @@
}
private:
- StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagsNV handleType;
- HANDLE handle;
+ using layout::ImportMemoryWin32HandleInfoNV::sType;
};
static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct ImportSemaphoreFdInfoKHR
+ namespace layout
{
- ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(),
- SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
- int fd_ = 0 )
- : semaphore( semaphore_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , fd( fd_ )
+ struct ImportSemaphoreFdInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : semaphore( semaphore_ )
+ , flags( flags_ )
+ , handleType( handleType_ )
+ , fd( fd_ )
+ {}
+
+ ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
+ }
+
+ ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
+ const void* pNext = nullptr;
+ vk::Semaphore semaphore;
+ vk::SemaphoreImportFlags flags;
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+ int fd;
+ };
+ static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportSemaphoreFdInfoKHR : public layout::ImportSemaphoreFdInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+ int fd_ = 0 )
+ : layout::ImportSemaphoreFdInfoKHR( semaphore_, flags_, handleType_, fd_ )
{}
ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
- }
+ : layout::ImportSemaphoreFdInfoKHR( rhs )
+ {}
ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
+ layout::ImportSemaphoreFdInfoKHR::operator=(rhs);
return *this;
}
@@ -33943,19 +41202,19 @@
return *this;
}
- ImportSemaphoreFdInfoKHR & setSemaphore( Semaphore semaphore_ )
+ ImportSemaphoreFdInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
{
semaphore = semaphore_;
return *this;
}
- ImportSemaphoreFdInfoKHR & setFlags( SemaphoreImportFlags flags_ )
+ ImportSemaphoreFdInfoKHR & setFlags( vk::SemaphoreImportFlags flags_ )
{
flags = flags_;
return *this;
}
- ImportSemaphoreFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ ImportSemaphoreFdInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -33993,40 +41252,70 @@
}
private:
- StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Semaphore semaphore;
- SemaphoreImportFlags flags;
- ExternalSemaphoreHandleTypeFlagBits handleType;
- int fd;
+ using layout::ImportSemaphoreFdInfoKHR::sType;
};
static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportSemaphoreFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct ImportSemaphoreWin32HandleInfoKHR
+
+ namespace layout
{
- ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
- SemaphoreImportFlags flags_ = SemaphoreImportFlags(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
- HANDLE handle_ = 0,
- LPCWSTR name_ = nullptr )
- : semaphore( semaphore_ )
- , flags( flags_ )
- , handleType( handleType_ )
- , handle( handle_ )
- , name( name_ )
+ struct ImportSemaphoreWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = nullptr )
+ : semaphore( semaphore_ )
+ , flags( flags_ )
+ , handleType( handleType_ )
+ , handle( handle_ )
+ , name( name_ )
+ {}
+
+ ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ vk::Semaphore semaphore;
+ vk::SemaphoreImportFlags flags;
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+ HANDLE handle;
+ LPCWSTR name;
+ };
+ static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ImportSemaphoreWin32HandleInfoKHR : public layout::ImportSemaphoreWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd,
+ HANDLE handle_ = 0,
+ LPCWSTR name_ = nullptr )
+ : layout::ImportSemaphoreWin32HandleInfoKHR( semaphore_, flags_, handleType_, handle_, name_ )
{}
ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
- }
+ : layout::ImportSemaphoreWin32HandleInfoKHR( rhs )
+ {}
ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
+ layout::ImportSemaphoreWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -34036,19 +41325,19 @@
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ )
+ ImportSemaphoreWin32HandleInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
{
semaphore = semaphore_;
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR & setFlags( SemaphoreImportFlags flags_ )
+ ImportSemaphoreWin32HandleInfoKHR & setFlags( vk::SemaphoreImportFlags flags_ )
{
flags = flags_;
return *this;
}
- ImportSemaphoreWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ ImportSemaphoreWin32HandleInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -34093,25 +41382,18 @@
}
private:
- StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Semaphore semaphore;
- SemaphoreImportFlags flags;
- ExternalSemaphoreHandleTypeFlagBits handleType;
- HANDLE handle;
- LPCWSTR name;
+ using layout::ImportSemaphoreWin32HandleInfoKHR::sType;
};
static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ImportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct IndirectCommandsLayoutTokenNVX
{
- IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline,
- uint32_t bindingUnit_ = 0,
- uint32_t dynamicCount_ = 0,
- uint32_t divisor_ = 0 )
+ VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNVX( vk::IndirectCommandsTokenTypeNVX tokenType_ = vk::IndirectCommandsTokenTypeNVX::ePipeline,
+ uint32_t bindingUnit_ = 0,
+ uint32_t dynamicCount_ = 0,
+ uint32_t divisor_ = 0 )
: tokenType( tokenType_ )
, bindingUnit( bindingUnit_ )
, dynamicCount( dynamicCount_ )
@@ -34120,16 +41402,16 @@
IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
+ *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this) = rhs;
}
IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
+ *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this) = rhs;
return *this;
}
- IndirectCommandsLayoutTokenNVX & setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
+ IndirectCommandsLayoutTokenNVX & setTokenType( vk::IndirectCommandsTokenTypeNVX tokenType_ )
{
tokenType = tokenType_;
return *this;
@@ -34176,33 +41458,68 @@
return !operator==( rhs );
}
- IndirectCommandsTokenTypeNVX tokenType;
+ public:
+ vk::IndirectCommandsTokenTypeNVX tokenType;
uint32_t bindingUnit;
uint32_t dynamicCount;
uint32_t divisor;
};
static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<IndirectCommandsLayoutTokenNVX>::value, "struct wrapper is not a standard layout!" );
- struct IndirectCommandsLayoutCreateInfoNVX
+ namespace layout
{
- IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(),
- uint32_t tokenCount_ = 0,
- const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
- : pipelineBindPoint( pipelineBindPoint_ )
- , flags( flags_ )
- , tokenCount( tokenCount_ )
- , pTokens( pTokens_ )
+ struct IndirectCommandsLayoutCreateInfoNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(),
+ uint32_t tokenCount_ = 0,
+ const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+ : pipelineBindPoint( pipelineBindPoint_ )
+ , flags( flags_ )
+ , tokenCount( tokenCount_ )
+ , pTokens( pTokens_ )
+ {}
+
+ IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
+ }
+
+ IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
+ const void* pNext = nullptr;
+ vk::PipelineBindPoint pipelineBindPoint;
+ vk::IndirectCommandsLayoutUsageFlagsNVX flags;
+ uint32_t tokenCount;
+ const vk::IndirectCommandsLayoutTokenNVX* pTokens;
+ };
+ static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct IndirectCommandsLayoutCreateInfoNVX : public layout::IndirectCommandsLayoutCreateInfoNVX
+ {
+ VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(),
+ uint32_t tokenCount_ = 0,
+ const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
+ : layout::IndirectCommandsLayoutCreateInfoNVX( pipelineBindPoint_, flags_, tokenCount_, pTokens_ )
{}
IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
- }
+ : layout::IndirectCommandsLayoutCreateInfoNVX( rhs )
+ {}
IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
+ layout::IndirectCommandsLayoutCreateInfoNVX::operator=(rhs);
return *this;
}
@@ -34212,13 +41529,13 @@
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
{
pipelineBindPoint = pipelineBindPoint_;
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX & setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
+ IndirectCommandsLayoutCreateInfoNVX & setFlags( vk::IndirectCommandsLayoutUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
@@ -34230,7 +41547,7 @@
return *this;
}
- IndirectCommandsLayoutCreateInfoNVX & setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
+ IndirectCommandsLayoutCreateInfoNVX & setPTokens( const vk::IndirectCommandsLayoutTokenNVX* pTokens_ )
{
pTokens = pTokens_;
return *this;
@@ -34262,31 +41579,52 @@
}
private:
- StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
-
- public:
- const void* pNext = nullptr;
- PipelineBindPoint pipelineBindPoint;
- IndirectCommandsLayoutUsageFlagsNVX flags;
- uint32_t tokenCount;
- const IndirectCommandsLayoutTokenNVX* pTokens;
+ using layout::IndirectCommandsLayoutCreateInfoNVX::sType;
};
static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<IndirectCommandsLayoutCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
- struct InitializePerformanceApiInfoINTEL
+ namespace layout
{
- InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr )
- : pUserData( pUserData_ )
+ struct InitializePerformanceApiInfoINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr )
+ : pUserData( pUserData_ )
+ {}
+
+ InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
+ }
+
+ InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL;
+ const void* pNext = nullptr;
+ void* pUserData;
+ };
+ static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct InitializePerformanceApiInfoINTEL : public layout::InitializePerformanceApiInfoINTEL
+ {
+ VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr )
+ : layout::InitializePerformanceApiInfoINTEL( pUserData_ )
{}
InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( InitializePerformanceApiInfoINTEL ) );
- }
+ : layout::InitializePerformanceApiInfoINTEL( rhs )
+ {}
InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( InitializePerformanceApiInfoINTEL ) );
+ layout::InitializePerformanceApiInfoINTEL::operator=(rhs);
return *this;
}
@@ -34325,19 +41663,16 @@
}
private:
- StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL;
-
- public:
- const void* pNext = nullptr;
- void* pUserData;
+ using layout::InitializePerformanceApiInfoINTEL::sType;
};
static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<InitializePerformanceApiInfoINTEL>::value, "struct wrapper is not a standard layout!" );
struct InputAttachmentAspectReference
{
- InputAttachmentAspectReference( uint32_t subpass_ = 0,
- uint32_t inputAttachmentIndex_ = 0,
- ImageAspectFlags aspectMask_ = ImageAspectFlags() )
+ VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( uint32_t subpass_ = 0,
+ uint32_t inputAttachmentIndex_ = 0,
+ vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() )
: subpass( subpass_ )
, inputAttachmentIndex( inputAttachmentIndex_ )
, aspectMask( aspectMask_ )
@@ -34345,12 +41680,12 @@
InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs )
{
- memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+ *reinterpret_cast<VkInputAttachmentAspectReference*>(this) = rhs;
}
InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs )
{
- memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
+ *reinterpret_cast<VkInputAttachmentAspectReference*>(this) = rhs;
return *this;
}
@@ -34366,7 +41701,7 @@
return *this;
}
- InputAttachmentAspectReference & setAspectMask( ImageAspectFlags aspectMask_ )
+ InputAttachmentAspectReference & setAspectMask( vk::ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
return *this;
@@ -34394,36 +41729,75 @@
return !operator==( rhs );
}
+ public:
uint32_t subpass;
uint32_t inputAttachmentIndex;
- ImageAspectFlags aspectMask;
+ vk::ImageAspectFlags aspectMask;
};
static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<InputAttachmentAspectReference>::value, "struct wrapper is not a standard layout!" );
- struct InstanceCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , pApplicationInfo( pApplicationInfo_ )
- , enabledLayerCount( enabledLayerCount_ )
- , ppEnabledLayerNames( ppEnabledLayerNames_ )
- , enabledExtensionCount( enabledExtensionCount_ )
- , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+ struct InstanceCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(),
+ const vk::ApplicationInfo* pApplicationInfo_ = nullptr,
+ uint32_t enabledLayerCount_ = 0,
+ const char* const* ppEnabledLayerNames_ = nullptr,
+ uint32_t enabledExtensionCount_ = 0,
+ const char* const* ppEnabledExtensionNames_ = nullptr )
+ : flags( flags_ )
+ , pApplicationInfo( pApplicationInfo_ )
+ , enabledLayerCount( enabledLayerCount_ )
+ , ppEnabledLayerNames( ppEnabledLayerNames_ )
+ , enabledExtensionCount( enabledExtensionCount_ )
+ , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
+ {}
+
+ InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkInstanceCreateInfo*>(this) = rhs;
+ }
+
+ InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkInstanceCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eInstanceCreateInfo;
+ const void* pNext = nullptr;
+ vk::InstanceCreateFlags flags;
+ const vk::ApplicationInfo* pApplicationInfo;
+ uint32_t enabledLayerCount;
+ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionCount;
+ const char* const* ppEnabledExtensionNames;
+ };
+ static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct InstanceCreateInfo : public layout::InstanceCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(),
+ const vk::ApplicationInfo* pApplicationInfo_ = nullptr,
+ uint32_t enabledLayerCount_ = 0,
+ const char* const* ppEnabledLayerNames_ = nullptr,
+ uint32_t enabledExtensionCount_ = 0,
+ const char* const* ppEnabledExtensionNames_ = nullptr )
+ : layout::InstanceCreateInfo( flags_, pApplicationInfo_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_ )
{}
InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
- }
+ : layout::InstanceCreateInfo( rhs )
+ {}
InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
+ layout::InstanceCreateInfo::operator=(rhs);
return *this;
}
@@ -34433,13 +41807,13 @@
return *this;
}
- InstanceCreateInfo & setFlags( InstanceCreateFlags flags_ )
+ InstanceCreateInfo & setFlags( vk::InstanceCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- InstanceCreateInfo & setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ )
+ InstanceCreateInfo & setPApplicationInfo( const vk::ApplicationInfo* pApplicationInfo_ )
{
pApplicationInfo = pApplicationInfo_;
return *this;
@@ -34497,21 +41871,27 @@
}
private:
- StructureType sType = StructureType::eInstanceCreateInfo;
-
- public:
- const void* pNext = nullptr;
- InstanceCreateFlags flags;
- const ApplicationInfo* pApplicationInfo;
- uint32_t enabledLayerCount;
- const char* const* ppEnabledLayerNames;
- uint32_t enabledExtensionCount;
- const char* const* ppEnabledExtensionNames;
+ using layout::InstanceCreateInfo::sType;
};
static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<InstanceCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct LayerProperties
{
+ LayerProperties()
+ {}
+
+ LayerProperties( VkLayerProperties const & rhs )
+ {
+ *reinterpret_cast<VkLayerProperties*>(this) = rhs;
+ }
+
+ LayerProperties& operator=( VkLayerProperties const & rhs )
+ {
+ *reinterpret_cast<VkLayerProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkLayerProperties const&() const
{
return *reinterpret_cast<const VkLayerProperties*>( this );
@@ -34535,30 +41915,62 @@
return !operator==( rhs );
}
+ public:
char layerName[VK_MAX_EXTENSION_NAME_SIZE];
uint32_t specVersion;
uint32_t implementationVersion;
char description[VK_MAX_DESCRIPTION_SIZE];
};
static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<LayerProperties>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_MACOS_MVK
- struct MacOSSurfaceCreateInfoMVK
+
+ namespace layout
{
- MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(),
- const void* pView_ = nullptr )
- : flags( flags_ )
- , pView( pView_ )
+ struct MacOSSurfaceCreateInfoMVK
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(),
+ const void* pView_ = nullptr )
+ : flags( flags_ )
+ , pView( pView_ )
+ {}
+
+ MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
+ {
+ *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
+ }
+
+ MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
+ {
+ *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
+ const void* pNext = nullptr;
+ vk::MacOSSurfaceCreateFlagsMVK flags;
+ const void* pView;
+ };
+ static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MacOSSurfaceCreateInfoMVK : public layout::MacOSSurfaceCreateInfoMVK
+ {
+ VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(),
+ const void* pView_ = nullptr )
+ : layout::MacOSSurfaceCreateInfoMVK( flags_, pView_ )
{}
MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
- {
- memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
- }
+ : layout::MacOSSurfaceCreateInfoMVK( rhs )
+ {}
MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
+ layout::MacOSSurfaceCreateInfoMVK::operator=(rhs);
return *this;
}
@@ -34568,7 +41980,7 @@
return *this;
}
- MacOSSurfaceCreateInfoMVK & setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
+ MacOSSurfaceCreateInfoMVK & setFlags( vk::MacOSSurfaceCreateFlagsMVK flags_ )
{
flags = flags_;
return *this;
@@ -34604,34 +42016,61 @@
}
private:
- StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
-
- public:
- const void* pNext = nullptr;
- MacOSSurfaceCreateFlagsMVK flags;
- const void* pView;
+ using layout::MacOSSurfaceCreateInfoMVK::sType;
};
static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MacOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
- struct MappedMemoryRange
+ namespace layout
{
- MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(),
- DeviceSize offset_ = 0,
- DeviceSize size_ = 0 )
- : memory( memory_ )
- , offset( offset_ )
- , size( size_ )
+ struct MappedMemoryRange
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize size_ = 0 )
+ : memory( memory_ )
+ , offset( offset_ )
+ , size( size_ )
+ {}
+
+ MappedMemoryRange( VkMappedMemoryRange const & rhs )
+ {
+ *reinterpret_cast<VkMappedMemoryRange*>(this) = rhs;
+ }
+
+ MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
+ {
+ *reinterpret_cast<VkMappedMemoryRange*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMappedMemoryRange;
+ const void* pNext = nullptr;
+ vk::DeviceMemory memory;
+ vk::DeviceSize offset;
+ vk::DeviceSize size;
+ };
+ static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MappedMemoryRange : public layout::MappedMemoryRange
+ {
+ VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::DeviceSize offset_ = 0,
+ vk::DeviceSize size_ = 0 )
+ : layout::MappedMemoryRange( memory_, offset_, size_ )
{}
MappedMemoryRange( VkMappedMemoryRange const & rhs )
- {
- memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
- }
+ : layout::MappedMemoryRange( rhs )
+ {}
MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
{
- memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
+ layout::MappedMemoryRange::operator=(rhs);
return *this;
}
@@ -34641,19 +42080,19 @@
return *this;
}
- MappedMemoryRange & setMemory( DeviceMemory memory_ )
+ MappedMemoryRange & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- MappedMemoryRange & setOffset( DeviceSize offset_ )
+ MappedMemoryRange & setOffset( vk::DeviceSize offset_ )
{
offset = offset_;
return *this;
}
- MappedMemoryRange & setSize( DeviceSize size_ )
+ MappedMemoryRange & setSize( vk::DeviceSize size_ )
{
size = size_;
return *this;
@@ -34684,32 +42123,56 @@
}
private:
- StructureType sType = StructureType::eMappedMemoryRange;
-
- public:
- const void* pNext = nullptr;
- DeviceMemory memory;
- DeviceSize offset;
- DeviceSize size;
+ using layout::MappedMemoryRange::sType;
};
static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MappedMemoryRange>::value, "struct wrapper is not a standard layout!" );
- struct MemoryAllocateFlagsInfo
+ namespace layout
{
- MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = MemoryAllocateFlags(),
- uint32_t deviceMask_ = 0 )
- : flags( flags_ )
- , deviceMask( deviceMask_ )
+ struct MemoryAllocateFlagsInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(),
+ uint32_t deviceMask_ = 0 )
+ : flags( flags_ )
+ , deviceMask( deviceMask_ )
+ {}
+
+ MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
+ {
+ *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this) = rhs;
+ }
+
+ MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
+ {
+ *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
+ const void* pNext = nullptr;
+ vk::MemoryAllocateFlags flags;
+ uint32_t deviceMask;
+ };
+ static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryAllocateFlagsInfo : public layout::MemoryAllocateFlagsInfo
+ {
+ VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(),
+ uint32_t deviceMask_ = 0 )
+ : layout::MemoryAllocateFlagsInfo( flags_, deviceMask_ )
{}
MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
- }
+ : layout::MemoryAllocateFlagsInfo( rhs )
+ {}
MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
+ layout::MemoryAllocateFlagsInfo::operator=(rhs);
return *this;
}
@@ -34719,7 +42182,7 @@
return *this;
}
- MemoryAllocateFlagsInfo & setFlags( MemoryAllocateFlags flags_ )
+ MemoryAllocateFlagsInfo & setFlags( vk::MemoryAllocateFlags flags_ )
{
flags = flags_;
return *this;
@@ -34755,31 +42218,56 @@
}
private:
- StructureType sType = StructureType::eMemoryAllocateFlagsInfo;
-
- public:
- const void* pNext = nullptr;
- MemoryAllocateFlags flags;
- uint32_t deviceMask;
+ using layout::MemoryAllocateFlagsInfo::sType;
};
static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryAllocateFlagsInfo>::value, "struct wrapper is not a standard layout!" );
- struct MemoryAllocateInfo
+ namespace layout
{
- MemoryAllocateInfo( DeviceSize allocationSize_ = 0,
- uint32_t memoryTypeIndex_ = 0 )
- : allocationSize( allocationSize_ )
- , memoryTypeIndex( memoryTypeIndex_ )
+ struct MemoryAllocateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0,
+ uint32_t memoryTypeIndex_ = 0 )
+ : allocationSize( allocationSize_ )
+ , memoryTypeIndex( memoryTypeIndex_ )
+ {}
+
+ MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
+ }
+
+ MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkMemoryAllocateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryAllocateInfo;
+ const void* pNext = nullptr;
+ vk::DeviceSize allocationSize;
+ uint32_t memoryTypeIndex;
+ };
+ static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryAllocateInfo : public layout::MemoryAllocateInfo
+ {
+ VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0,
+ uint32_t memoryTypeIndex_ = 0 )
+ : layout::MemoryAllocateInfo( allocationSize_, memoryTypeIndex_ )
{}
MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
- }
+ : layout::MemoryAllocateInfo( rhs )
+ {}
MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
+ layout::MemoryAllocateInfo::operator=(rhs);
return *this;
}
@@ -34789,7 +42277,7 @@
return *this;
}
- MemoryAllocateInfo & setAllocationSize( DeviceSize allocationSize_ )
+ MemoryAllocateInfo & setAllocationSize( vk::DeviceSize allocationSize_ )
{
allocationSize = allocationSize_;
return *this;
@@ -34825,31 +42313,56 @@
}
private:
- StructureType sType = StructureType::eMemoryAllocateInfo;
-
- public:
- const void* pNext = nullptr;
- DeviceSize allocationSize;
- uint32_t memoryTypeIndex;
+ using layout::MemoryAllocateInfo::sType;
};
static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" );
- struct MemoryBarrier
+ namespace layout
{
- MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags() )
- : srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
+ struct MemoryBarrier
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags() )
+ : srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ {}
+
+ MemoryBarrier( VkMemoryBarrier const & rhs )
+ {
+ *reinterpret_cast<VkMemoryBarrier*>(this) = rhs;
+ }
+
+ MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
+ {
+ *reinterpret_cast<VkMemoryBarrier*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryBarrier;
+ const void* pNext = nullptr;
+ vk::AccessFlags srcAccessMask;
+ vk::AccessFlags dstAccessMask;
+ };
+ static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryBarrier : public layout::MemoryBarrier
+ {
+ VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags() )
+ : layout::MemoryBarrier( srcAccessMask_, dstAccessMask_ )
{}
MemoryBarrier( VkMemoryBarrier const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryBarrier ) );
- }
+ : layout::MemoryBarrier( rhs )
+ {}
MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryBarrier ) );
+ layout::MemoryBarrier::operator=(rhs);
return *this;
}
@@ -34859,13 +42372,13 @@
return *this;
}
- MemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ )
+ MemoryBarrier & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
{
srcAccessMask = srcAccessMask_;
return *this;
}
- MemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ )
+ MemoryBarrier & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
{
dstAccessMask = dstAccessMask_;
return *this;
@@ -34895,31 +42408,56 @@
}
private:
- StructureType sType = StructureType::eMemoryBarrier;
-
- public:
- const void* pNext = nullptr;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
+ using layout::MemoryBarrier::sType;
};
static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryBarrier>::value, "struct wrapper is not a standard layout!" );
- struct MemoryDedicatedAllocateInfo
+ namespace layout
{
- MemoryDedicatedAllocateInfo( Image image_ = Image(),
- Buffer buffer_ = Buffer() )
- : image( image_ )
- , buffer( buffer_ )
+ struct MemoryDedicatedAllocateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(),
+ vk::Buffer buffer_ = vk::Buffer() )
+ : image( image_ )
+ , buffer( buffer_ )
+ {}
+
+ MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
+ }
+
+ MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs )
+ {
+ *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
+ const void* pNext = nullptr;
+ vk::Image image;
+ vk::Buffer buffer;
+ };
+ static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryDedicatedAllocateInfo : public layout::MemoryDedicatedAllocateInfo
+ {
+ VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(),
+ vk::Buffer buffer_ = vk::Buffer() )
+ : layout::MemoryDedicatedAllocateInfo( image_, buffer_ )
{}
MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
- }
+ : layout::MemoryDedicatedAllocateInfo( rhs )
+ {}
MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
+ layout::MemoryDedicatedAllocateInfo::operator=(rhs);
return *this;
}
@@ -34929,13 +42467,13 @@
return *this;
}
- MemoryDedicatedAllocateInfo & setImage( Image image_ )
+ MemoryDedicatedAllocateInfo & setImage( vk::Image image_ )
{
image = image_;
return *this;
}
- MemoryDedicatedAllocateInfo & setBuffer( Buffer buffer_ )
+ MemoryDedicatedAllocateInfo & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
@@ -34965,17 +42503,55 @@
}
private:
- StructureType sType = StructureType::eMemoryDedicatedAllocateInfo;
-
- public:
- const void* pNext = nullptr;
- Image image;
- Buffer buffer;
+ using layout::MemoryDedicatedAllocateInfo::sType;
};
static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryDedicatedAllocateInfo>::value, "struct wrapper is not a standard layout!" );
- struct MemoryDedicatedRequirements
+ namespace layout
{
+ struct MemoryDedicatedRequirements
+ {
+ protected:
+ MemoryDedicatedRequirements()
+ {}
+
+ MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs )
+ {
+ *reinterpret_cast<VkMemoryDedicatedRequirements*>(this) = rhs;
+ }
+
+ MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs )
+ {
+ *reinterpret_cast<VkMemoryDedicatedRequirements*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryDedicatedRequirements;
+ void* pNext = nullptr;
+ vk::Bool32 prefersDedicatedAllocation;
+ vk::Bool32 requiresDedicatedAllocation;
+ };
+ static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryDedicatedRequirements : public layout::MemoryDedicatedRequirements
+ {
+ MemoryDedicatedRequirements()
+ : layout::MemoryDedicatedRequirements()
+ {}
+
+ MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs )
+ : layout::MemoryDedicatedRequirements( rhs )
+ {}
+
+ MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs )
+ {
+ layout::MemoryDedicatedRequirements::operator=(rhs);
+ return *this;
+ }
+
operator VkMemoryDedicatedRequirements const&() const
{
return *reinterpret_cast<const VkMemoryDedicatedRequirements*>( this );
@@ -35000,17 +42576,54 @@
}
private:
- StructureType sType = StructureType::eMemoryDedicatedRequirements;
-
- public:
- void* pNext = nullptr;
- Bool32 prefersDedicatedAllocation;
- Bool32 requiresDedicatedAllocation;
+ using layout::MemoryDedicatedRequirements::sType;
};
static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryDedicatedRequirements>::value, "struct wrapper is not a standard layout!" );
- struct MemoryFdPropertiesKHR
+ namespace layout
{
+ struct MemoryFdPropertiesKHR
+ {
+ protected:
+ MemoryFdPropertiesKHR()
+ {}
+
+ MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this) = rhs;
+ }
+
+ MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR;
+ void* pNext = nullptr;
+ uint32_t memoryTypeBits;
+ };
+ static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryFdPropertiesKHR : public layout::MemoryFdPropertiesKHR
+ {
+ MemoryFdPropertiesKHR()
+ : layout::MemoryFdPropertiesKHR()
+ {}
+
+ MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs )
+ : layout::MemoryFdPropertiesKHR( rhs )
+ {}
+
+ MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs )
+ {
+ layout::MemoryFdPropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkMemoryFdPropertiesKHR const&() const
{
return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>( this );
@@ -35034,29 +42647,54 @@
}
private:
- StructureType sType = StructureType::eMemoryFdPropertiesKHR;
-
- public:
- void* pNext = nullptr;
- uint32_t memoryTypeBits;
+ using layout::MemoryFdPropertiesKHR::sType;
};
static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryFdPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- struct MemoryGetAndroidHardwareBufferInfoANDROID
+
+ namespace layout
{
- MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() )
- : memory( memory_ )
+ struct MemoryGetAndroidHardwareBufferInfoANDROID
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() )
+ : memory( memory_ )
+ {}
+
+ MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
+ {
+ *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+ }
+
+ MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
+ {
+ *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
+ const void* pNext = nullptr;
+ vk::DeviceMemory memory;
+ };
+ static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryGetAndroidHardwareBufferInfoANDROID : public layout::MemoryGetAndroidHardwareBufferInfoANDROID
+ {
+ VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() )
+ : layout::MemoryGetAndroidHardwareBufferInfoANDROID( memory_ )
{}
MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
- }
+ : layout::MemoryGetAndroidHardwareBufferInfoANDROID( rhs )
+ {}
MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
+ layout::MemoryGetAndroidHardwareBufferInfoANDROID::operator=(rhs);
return *this;
}
@@ -35066,7 +42704,7 @@
return *this;
}
- MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( DeviceMemory memory_ )
+ MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
@@ -35095,31 +42733,57 @@
}
private:
- StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID;
-
- public:
- const void* pNext = nullptr;
- DeviceMemory memory;
+ using layout::MemoryGetAndroidHardwareBufferInfoANDROID::sType;
};
static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryGetAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- struct MemoryGetFdInfoKHR
+ namespace layout
{
- MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(),
- ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : memory( memory_ )
- , handleType( handleType_ )
+ struct MemoryGetFdInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : memory( memory_ )
+ , handleType( handleType_ )
+ {}
+
+ MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this) = rhs;
+ }
+
+ MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR;
+ const void* pNext = nullptr;
+ vk::DeviceMemory memory;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryGetFdInfoKHR : public layout::MemoryGetFdInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : layout::MemoryGetFdInfoKHR( memory_, handleType_ )
{}
MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
- }
+ : layout::MemoryGetFdInfoKHR( rhs )
+ {}
MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
+ layout::MemoryGetFdInfoKHR::operator=(rhs);
return *this;
}
@@ -35129,13 +42793,13 @@
return *this;
}
- MemoryGetFdInfoKHR & setMemory( DeviceMemory memory_ )
+ MemoryGetFdInfoKHR & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- MemoryGetFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ MemoryGetFdInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -35165,32 +42829,58 @@
}
private:
- StructureType sType = StructureType::eMemoryGetFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- DeviceMemory memory;
- ExternalMemoryHandleTypeFlagBits handleType;
+ using layout::MemoryGetFdInfoKHR::sType;
};
static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct MemoryGetWin32HandleInfoKHR
+
+ namespace layout
{
- MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
- ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : memory( memory_ )
- , handleType( handleType_ )
+ struct MemoryGetWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : memory( memory_ )
+ , handleType( handleType_ )
+ {}
+
+ MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ vk::DeviceMemory memory;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryGetWin32HandleInfoKHR : public layout::MemoryGetWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(),
+ vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : layout::MemoryGetWin32HandleInfoKHR( memory_, handleType_ )
{}
MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
- }
+ : layout::MemoryGetWin32HandleInfoKHR( rhs )
+ {}
MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
+ layout::MemoryGetWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -35200,13 +42890,13 @@
return *this;
}
- MemoryGetWin32HandleInfoKHR & setMemory( DeviceMemory memory_ )
+ MemoryGetWin32HandleInfoKHR & setMemory( vk::DeviceMemory memory_ )
{
memory = memory_;
return *this;
}
- MemoryGetWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ MemoryGetWin32HandleInfoKHR & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -35236,18 +42926,28 @@
}
private:
- StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- DeviceMemory memory;
- ExternalMemoryHandleTypeFlagBits handleType;
+ using layout::MemoryGetWin32HandleInfoKHR::sType;
};
static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct MemoryHeap
{
+ MemoryHeap()
+ {}
+
+ MemoryHeap( VkMemoryHeap const & rhs )
+ {
+ *reinterpret_cast<VkMemoryHeap*>(this) = rhs;
+ }
+
+ MemoryHeap& operator=( VkMemoryHeap const & rhs )
+ {
+ *reinterpret_cast<VkMemoryHeap*>(this) = rhs;
+ return *this;
+ }
+
operator VkMemoryHeap const&() const
{
return *reinterpret_cast<const VkMemoryHeap*>( this );
@@ -35269,13 +42969,56 @@
return !operator==( rhs );
}
- DeviceSize size;
- MemoryHeapFlags flags;
+ public:
+ vk::DeviceSize size;
+ vk::MemoryHeapFlags flags;
};
static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryHeap>::value, "struct wrapper is not a standard layout!" );
- struct MemoryHostPointerPropertiesEXT
+ namespace layout
{
+ struct MemoryHostPointerPropertiesEXT
+ {
+ protected:
+ MemoryHostPointerPropertiesEXT()
+ {}
+
+ MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this) = rhs;
+ }
+
+ MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t memoryTypeBits;
+ };
+ static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryHostPointerPropertiesEXT : public layout::MemoryHostPointerPropertiesEXT
+ {
+ MemoryHostPointerPropertiesEXT()
+ : layout::MemoryHostPointerPropertiesEXT()
+ {}
+
+ MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
+ : layout::MemoryHostPointerPropertiesEXT( rhs )
+ {}
+
+ MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
+ {
+ layout::MemoryHostPointerPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkMemoryHostPointerPropertiesEXT const&() const
{
return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>( this );
@@ -35299,28 +43042,52 @@
}
private:
- StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t memoryTypeBits;
+ using layout::MemoryHostPointerPropertiesEXT::sType;
};
static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryHostPointerPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct MemoryPriorityAllocateInfoEXT
+ namespace layout
{
- MemoryPriorityAllocateInfoEXT( float priority_ = 0 )
- : priority( priority_ )
+ struct MemoryPriorityAllocateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 )
+ : priority( priority_ )
+ {}
+
+ MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
+ }
+
+ MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
+ const void* pNext = nullptr;
+ float priority;
+ };
+ static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryPriorityAllocateInfoEXT : public layout::MemoryPriorityAllocateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 )
+ : layout::MemoryPriorityAllocateInfoEXT( priority_ )
{}
MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) );
- }
+ : layout::MemoryPriorityAllocateInfoEXT( rhs )
+ {}
MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( MemoryPriorityAllocateInfoEXT ) );
+ layout::MemoryPriorityAllocateInfoEXT::operator=(rhs);
return *this;
}
@@ -35359,16 +43126,27 @@
}
private:
- StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- float priority;
+ using layout::MemoryPriorityAllocateInfoEXT::sType;
};
static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryPriorityAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
struct MemoryRequirements
{
+ MemoryRequirements()
+ {}
+
+ MemoryRequirements( VkMemoryRequirements const & rhs )
+ {
+ *reinterpret_cast<VkMemoryRequirements*>(this) = rhs;
+ }
+
+ MemoryRequirements& operator=( VkMemoryRequirements const & rhs )
+ {
+ *reinterpret_cast<VkMemoryRequirements*>(this) = rhs;
+ return *this;
+ }
+
operator VkMemoryRequirements const&() const
{
return *reinterpret_cast<const VkMemoryRequirements*>( this );
@@ -35391,14 +43169,57 @@
return !operator==( rhs );
}
- DeviceSize size;
- DeviceSize alignment;
+ public:
+ vk::DeviceSize size;
+ vk::DeviceSize alignment;
uint32_t memoryTypeBits;
};
static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryRequirements>::value, "struct wrapper is not a standard layout!" );
- struct MemoryRequirements2
+ namespace layout
{
+ struct MemoryRequirements2
+ {
+ protected:
+ MemoryRequirements2()
+ {}
+
+ MemoryRequirements2( VkMemoryRequirements2 const & rhs )
+ {
+ *reinterpret_cast<VkMemoryRequirements2*>(this) = rhs;
+ }
+
+ MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs )
+ {
+ *reinterpret_cast<VkMemoryRequirements2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryRequirements2;
+ void* pNext = nullptr;
+ vk::MemoryRequirements memoryRequirements;
+ };
+ static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryRequirements2 : public layout::MemoryRequirements2
+ {
+ MemoryRequirements2()
+ : layout::MemoryRequirements2()
+ {}
+
+ MemoryRequirements2( VkMemoryRequirements2 const & rhs )
+ : layout::MemoryRequirements2( rhs )
+ {}
+
+ MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs )
+ {
+ layout::MemoryRequirements2::operator=(rhs);
+ return *this;
+ }
+
operator VkMemoryRequirements2 const&() const
{
return *reinterpret_cast<const VkMemoryRequirements2*>( this );
@@ -35422,16 +43243,27 @@
}
private:
- StructureType sType = StructureType::eMemoryRequirements2;
-
- public:
- void* pNext = nullptr;
- MemoryRequirements memoryRequirements;
+ using layout::MemoryRequirements2::sType;
};
static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryRequirements2>::value, "struct wrapper is not a standard layout!" );
struct MemoryType
{
+ MemoryType()
+ {}
+
+ MemoryType( VkMemoryType const & rhs )
+ {
+ *reinterpret_cast<VkMemoryType*>(this) = rhs;
+ }
+
+ MemoryType& operator=( VkMemoryType const & rhs )
+ {
+ *reinterpret_cast<VkMemoryType*>(this) = rhs;
+ return *this;
+ }
+
operator VkMemoryType const&() const
{
return *reinterpret_cast<const VkMemoryType*>( this );
@@ -35453,14 +43285,58 @@
return !operator==( rhs );
}
- MemoryPropertyFlags propertyFlags;
+ public:
+ vk::MemoryPropertyFlags propertyFlags;
uint32_t heapIndex;
};
static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryType>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct MemoryWin32HandlePropertiesKHR
+
+ namespace layout
{
+ struct MemoryWin32HandlePropertiesKHR
+ {
+ protected:
+ MemoryWin32HandlePropertiesKHR()
+ {}
+
+ MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this) = rhs;
+ }
+
+ MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
+ void* pNext = nullptr;
+ uint32_t memoryTypeBits;
+ };
+ static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MemoryWin32HandlePropertiesKHR : public layout::MemoryWin32HandlePropertiesKHR
+ {
+ MemoryWin32HandlePropertiesKHR()
+ : layout::MemoryWin32HandlePropertiesKHR()
+ {}
+
+ MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs )
+ : layout::MemoryWin32HandlePropertiesKHR( rhs )
+ {}
+
+ MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs )
+ {
+ layout::MemoryWin32HandlePropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkMemoryWin32HandlePropertiesKHR const&() const
{
return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>( this );
@@ -35484,32 +43360,59 @@
}
private:
- StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
-
- public:
- void* pNext = nullptr;
- uint32_t memoryTypeBits;
+ using layout::MemoryWin32HandlePropertiesKHR::sType;
};
static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MemoryWin32HandlePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_METAL_EXT
- struct MetalSurfaceCreateInfoEXT
+
+ namespace layout
{
- MetalSurfaceCreateInfoEXT( MetalSurfaceCreateFlagsEXT flags_ = MetalSurfaceCreateFlagsEXT(),
- const CAMetalLayer* pLayer_ = nullptr )
- : flags( flags_ )
- , pLayer( pLayer_ )
+ struct MetalSurfaceCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(),
+ const CAMetalLayer* pLayer_ = nullptr )
+ : flags( flags_ )
+ , pLayer( pLayer_ )
+ {}
+
+ MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
+ }
+
+ MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::MetalSurfaceCreateFlagsEXT flags;
+ const CAMetalLayer* pLayer;
+ };
+ static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MetalSurfaceCreateInfoEXT : public layout::MetalSurfaceCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(),
+ const CAMetalLayer* pLayer_ = nullptr )
+ : layout::MetalSurfaceCreateInfoEXT( flags_, pLayer_ )
{}
MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( MetalSurfaceCreateInfoEXT ) );
- }
+ : layout::MetalSurfaceCreateInfoEXT( rhs )
+ {}
MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( MetalSurfaceCreateInfoEXT ) );
+ layout::MetalSurfaceCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -35519,7 +43422,7 @@
return *this;
}
- MetalSurfaceCreateInfoEXT & setFlags( MetalSurfaceCreateFlagsEXT flags_ )
+ MetalSurfaceCreateInfoEXT & setFlags( vk::MetalSurfaceCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -35555,18 +43458,55 @@
}
private:
- StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- MetalSurfaceCreateFlagsEXT flags;
- const CAMetalLayer* pLayer;
+ using layout::MetalSurfaceCreateInfoEXT::sType;
};
static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MetalSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
- struct MultisamplePropertiesEXT
+ namespace layout
{
+ struct MultisamplePropertiesEXT
+ {
+ protected:
+ MultisamplePropertiesEXT()
+ {}
+
+ MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkMultisamplePropertiesEXT*>(this) = rhs;
+ }
+
+ MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkMultisamplePropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eMultisamplePropertiesEXT;
+ void* pNext = nullptr;
+ vk::Extent2D maxSampleLocationGridSize;
+ };
+ static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct MultisamplePropertiesEXT : public layout::MultisamplePropertiesEXT
+ {
+ MultisamplePropertiesEXT()
+ : layout::MultisamplePropertiesEXT()
+ {}
+
+ MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs )
+ : layout::MultisamplePropertiesEXT( rhs )
+ {}
+
+ MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs )
+ {
+ layout::MultisamplePropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkMultisamplePropertiesEXT const&() const
{
return *reinterpret_cast<const VkMultisamplePropertiesEXT*>( this );
@@ -35590,44 +43530,84 @@
}
private:
- StructureType sType = StructureType::eMultisamplePropertiesEXT;
-
- public:
- void* pNext = nullptr;
- Extent2D maxSampleLocationGridSize;
+ using layout::MultisamplePropertiesEXT::sType;
};
static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<MultisamplePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct ObjectTableCreateInfoNVX
+ namespace layout
{
- ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
- const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
- const uint32_t* pObjectEntryCounts_ = nullptr,
- const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
- uint32_t maxUniformBuffersPerDescriptor_ = 0,
- uint32_t maxStorageBuffersPerDescriptor_ = 0,
- uint32_t maxStorageImagesPerDescriptor_ = 0,
- uint32_t maxSampledImagesPerDescriptor_ = 0,
- uint32_t maxPipelineLayouts_ = 0 )
- : objectCount( objectCount_ )
- , pObjectEntryTypes( pObjectEntryTypes_ )
- , pObjectEntryCounts( pObjectEntryCounts_ )
- , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
- , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
- , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
- , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
- , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
- , maxPipelineLayouts( maxPipelineLayouts_ )
+ struct ObjectTableCreateInfoNVX
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
+ const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
+ const uint32_t* pObjectEntryCounts_ = nullptr,
+ const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
+ uint32_t maxUniformBuffersPerDescriptor_ = 0,
+ uint32_t maxStorageBuffersPerDescriptor_ = 0,
+ uint32_t maxStorageImagesPerDescriptor_ = 0,
+ uint32_t maxSampledImagesPerDescriptor_ = 0,
+ uint32_t maxPipelineLayouts_ = 0 )
+ : objectCount( objectCount_ )
+ , pObjectEntryTypes( pObjectEntryTypes_ )
+ , pObjectEntryCounts( pObjectEntryCounts_ )
+ , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
+ , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
+ , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
+ , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
+ , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
+ , maxPipelineLayouts( maxPipelineLayouts_ )
+ {}
+
+ ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this) = rhs;
+ }
+
+ ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
+ {
+ *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eObjectTableCreateInfoNVX;
+ const void* pNext = nullptr;
+ uint32_t objectCount;
+ const vk::ObjectEntryTypeNVX* pObjectEntryTypes;
+ const uint32_t* pObjectEntryCounts;
+ const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
+ uint32_t maxUniformBuffersPerDescriptor;
+ uint32_t maxStorageBuffersPerDescriptor;
+ uint32_t maxStorageImagesPerDescriptor;
+ uint32_t maxSampledImagesPerDescriptor;
+ uint32_t maxPipelineLayouts;
+ };
+ static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ObjectTableCreateInfoNVX : public layout::ObjectTableCreateInfoNVX
+ {
+ VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0,
+ const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
+ const uint32_t* pObjectEntryCounts_ = nullptr,
+ const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
+ uint32_t maxUniformBuffersPerDescriptor_ = 0,
+ uint32_t maxStorageBuffersPerDescriptor_ = 0,
+ uint32_t maxStorageImagesPerDescriptor_ = 0,
+ uint32_t maxSampledImagesPerDescriptor_ = 0,
+ uint32_t maxPipelineLayouts_ = 0 )
+ : layout::ObjectTableCreateInfoNVX( objectCount_, pObjectEntryTypes_, pObjectEntryCounts_, pObjectEntryUsageFlags_, maxUniformBuffersPerDescriptor_, maxStorageBuffersPerDescriptor_, maxStorageImagesPerDescriptor_, maxSampledImagesPerDescriptor_, maxPipelineLayouts_ )
{}
ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
- {
- memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
- }
+ : layout::ObjectTableCreateInfoNVX( rhs )
+ {}
ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
+ layout::ObjectTableCreateInfoNVX::operator=(rhs);
return *this;
}
@@ -35643,7 +43623,7 @@
return *this;
}
- ObjectTableCreateInfoNVX & setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
+ ObjectTableCreateInfoNVX & setPObjectEntryTypes( const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ )
{
pObjectEntryTypes = pObjectEntryTypes_;
return *this;
@@ -35655,7 +43635,7 @@
return *this;
}
- ObjectTableCreateInfoNVX & setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
+ ObjectTableCreateInfoNVX & setPObjectEntryUsageFlags( const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
{
pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
return *this;
@@ -35722,48 +43702,37 @@
}
private:
- StructureType sType = StructureType::eObjectTableCreateInfoNVX;
-
- public:
- const void* pNext = nullptr;
- uint32_t objectCount;
- const ObjectEntryTypeNVX* pObjectEntryTypes;
- const uint32_t* pObjectEntryCounts;
- const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
- uint32_t maxUniformBuffersPerDescriptor;
- uint32_t maxStorageBuffersPerDescriptor;
- uint32_t maxStorageImagesPerDescriptor;
- uint32_t maxSampledImagesPerDescriptor;
- uint32_t maxPipelineLayouts;
+ using layout::ObjectTableCreateInfoNVX::sType;
};
static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTableCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
struct ObjectTableEntryNVX
{
- ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
+ VULKAN_HPP_CONSTEXPR ObjectTableEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+ vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX() )
: type( type_ )
, flags( flags_ )
{}
ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
+ *reinterpret_cast<VkObjectTableEntryNVX*>(this) = rhs;
}
ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
+ *reinterpret_cast<VkObjectTableEntryNVX*>(this) = rhs;
return *this;
}
- ObjectTableEntryNVX & setType( ObjectEntryTypeNVX type_ )
+ ObjectTableEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
{
type = type_;
return *this;
}
- ObjectTableEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ObjectTableEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
@@ -35790,17 +43759,19 @@
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
+ public:
+ vk::ObjectEntryTypeNVX type;
+ vk::ObjectEntryUsageFlagsNVX flags;
};
static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTableEntryNVX>::value, "struct wrapper is not a standard layout!" );
struct ObjectTableDescriptorSetEntryNVX
{
- ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- DescriptorSet descriptorSet_ = DescriptorSet() )
+ VULKAN_HPP_CONSTEXPR ObjectTableDescriptorSetEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+ vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+ vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+ vk::DescriptorSet descriptorSet_ = vk::DescriptorSet() )
: type( type_ )
, flags( flags_ )
, pipelineLayout( pipelineLayout_ )
@@ -35808,8 +43779,8 @@
{}
explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- DescriptorSet descriptorSet_ = DescriptorSet() )
+ vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+ vk::DescriptorSet descriptorSet_ = vk::DescriptorSet() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, pipelineLayout( pipelineLayout_ )
@@ -35818,34 +43789,34 @@
ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
+ *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this) = rhs;
}
ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
+ *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this) = rhs;
return *this;
}
- ObjectTableDescriptorSetEntryNVX & setType( ObjectEntryTypeNVX type_ )
+ ObjectTableDescriptorSetEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
{
type = type_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ObjectTableDescriptorSetEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX & setPipelineLayout( PipelineLayout pipelineLayout_ )
+ ObjectTableDescriptorSetEntryNVX & setPipelineLayout( vk::PipelineLayout pipelineLayout_ )
{
pipelineLayout = pipelineLayout_;
return *this;
}
- ObjectTableDescriptorSetEntryNVX & setDescriptorSet( DescriptorSet descriptorSet_ )
+ ObjectTableDescriptorSetEntryNVX & setDescriptorSet( vk::DescriptorSet descriptorSet_ )
{
descriptorSet = descriptorSet_;
return *this;
@@ -35874,19 +43845,21 @@
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- PipelineLayout pipelineLayout;
- DescriptorSet descriptorSet;
+ public:
+ vk::ObjectEntryTypeNVX type;
+ vk::ObjectEntryUsageFlagsNVX flags;
+ vk::PipelineLayout pipelineLayout;
+ vk::DescriptorSet descriptorSet;
};
static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTableDescriptorSetEntryNVX>::value, "struct wrapper is not a standard layout!" );
struct ObjectTableIndexBufferEntryNVX
{
- ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- Buffer buffer_ = Buffer(),
- IndexType indexType_ = IndexType::eUint16 )
+ VULKAN_HPP_CONSTEXPR ObjectTableIndexBufferEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+ vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::IndexType indexType_ = vk::IndexType::eUint16 )
: type( type_ )
, flags( flags_ )
, buffer( buffer_ )
@@ -35894,8 +43867,8 @@
{}
explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- Buffer buffer_ = Buffer(),
- IndexType indexType_ = IndexType::eUint16 )
+ vk::Buffer buffer_ = vk::Buffer(),
+ vk::IndexType indexType_ = vk::IndexType::eUint16 )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, buffer( buffer_ )
@@ -35904,34 +43877,34 @@
ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
+ *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this) = rhs;
}
ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
+ *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this) = rhs;
return *this;
}
- ObjectTableIndexBufferEntryNVX & setType( ObjectEntryTypeNVX type_ )
+ ObjectTableIndexBufferEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
{
type = type_;
return *this;
}
- ObjectTableIndexBufferEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ObjectTableIndexBufferEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- ObjectTableIndexBufferEntryNVX & setBuffer( Buffer buffer_ )
+ ObjectTableIndexBufferEntryNVX & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
}
- ObjectTableIndexBufferEntryNVX & setIndexType( IndexType indexType_ )
+ ObjectTableIndexBufferEntryNVX & setIndexType( vk::IndexType indexType_ )
{
indexType = indexType_;
return *this;
@@ -35960,25 +43933,27 @@
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Buffer buffer;
- IndexType indexType;
+ public:
+ vk::ObjectEntryTypeNVX type;
+ vk::ObjectEntryUsageFlagsNVX flags;
+ vk::Buffer buffer;
+ vk::IndexType indexType;
};
static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTableIndexBufferEntryNVX>::value, "struct wrapper is not a standard layout!" );
struct ObjectTablePipelineEntryNVX
{
- ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- Pipeline pipeline_ = Pipeline() )
+ VULKAN_HPP_CONSTEXPR ObjectTablePipelineEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+ vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+ vk::Pipeline pipeline_ = vk::Pipeline() )
: type( type_ )
, flags( flags_ )
, pipeline( pipeline_ )
{}
explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- Pipeline pipeline_ = Pipeline() )
+ vk::Pipeline pipeline_ = vk::Pipeline() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, pipeline( pipeline_ )
@@ -35986,28 +43961,28 @@
ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+ *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this) = rhs;
}
ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
+ *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this) = rhs;
return *this;
}
- ObjectTablePipelineEntryNVX & setType( ObjectEntryTypeNVX type_ )
+ ObjectTablePipelineEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
{
type = type_;
return *this;
}
- ObjectTablePipelineEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ObjectTablePipelineEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- ObjectTablePipelineEntryNVX & setPipeline( Pipeline pipeline_ )
+ ObjectTablePipelineEntryNVX & setPipeline( vk::Pipeline pipeline_ )
{
pipeline = pipeline_;
return *this;
@@ -36035,18 +44010,20 @@
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Pipeline pipeline;
+ public:
+ vk::ObjectEntryTypeNVX type;
+ vk::ObjectEntryUsageFlagsNVX flags;
+ vk::Pipeline pipeline;
};
static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTablePipelineEntryNVX>::value, "struct wrapper is not a standard layout!" );
struct ObjectTablePushConstantEntryNVX
{
- ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+ VULKAN_HPP_CONSTEXPR ObjectTablePushConstantEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+ vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+ vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+ vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags() )
: type( type_ )
, flags( flags_ )
, pipelineLayout( pipelineLayout_ )
@@ -36054,8 +44031,8 @@
{}
explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- PipelineLayout pipelineLayout_ = PipelineLayout(),
- ShaderStageFlags stageFlags_ = ShaderStageFlags() )
+ vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(),
+ vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, pipelineLayout( pipelineLayout_ )
@@ -36064,34 +44041,34 @@
ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
+ *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this) = rhs;
}
ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
+ *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this) = rhs;
return *this;
}
- ObjectTablePushConstantEntryNVX & setType( ObjectEntryTypeNVX type_ )
+ ObjectTablePushConstantEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
{
type = type_;
return *this;
}
- ObjectTablePushConstantEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ObjectTablePushConstantEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- ObjectTablePushConstantEntryNVX & setPipelineLayout( PipelineLayout pipelineLayout_ )
+ ObjectTablePushConstantEntryNVX & setPipelineLayout( vk::PipelineLayout pipelineLayout_ )
{
pipelineLayout = pipelineLayout_;
return *this;
}
- ObjectTablePushConstantEntryNVX & setStageFlags( ShaderStageFlags stageFlags_ )
+ ObjectTablePushConstantEntryNVX & setStageFlags( vk::ShaderStageFlags stageFlags_ )
{
stageFlags = stageFlags_;
return *this;
@@ -36120,25 +44097,27 @@
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- PipelineLayout pipelineLayout;
- ShaderStageFlags stageFlags;
+ public:
+ vk::ObjectEntryTypeNVX type;
+ vk::ObjectEntryUsageFlagsNVX flags;
+ vk::PipelineLayout pipelineLayout;
+ vk::ShaderStageFlags stageFlags;
};
static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTablePushConstantEntryNVX>::value, "struct wrapper is not a standard layout!" );
struct ObjectTableVertexBufferEntryNVX
{
- ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet,
- ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(),
- Buffer buffer_ = Buffer() )
+ VULKAN_HPP_CONSTEXPR ObjectTableVertexBufferEntryNVX( vk::ObjectEntryTypeNVX type_ = vk::ObjectEntryTypeNVX::eDescriptorSet,
+ vk::ObjectEntryUsageFlagsNVX flags_ = vk::ObjectEntryUsageFlagsNVX(),
+ vk::Buffer buffer_ = vk::Buffer() )
: type( type_ )
, flags( flags_ )
, buffer( buffer_ )
{}
explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
- Buffer buffer_ = Buffer() )
+ vk::Buffer buffer_ = vk::Buffer() )
: type( objectTableEntryNVX.type )
, flags( objectTableEntryNVX.flags )
, buffer( buffer_ )
@@ -36146,28 +44125,28 @@
ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+ *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this) = rhs;
}
ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
+ *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this) = rhs;
return *this;
}
- ObjectTableVertexBufferEntryNVX & setType( ObjectEntryTypeNVX type_ )
+ ObjectTableVertexBufferEntryNVX & setType( vk::ObjectEntryTypeNVX type_ )
{
type = type_;
return *this;
}
- ObjectTableVertexBufferEntryNVX & setFlags( ObjectEntryUsageFlagsNVX flags_ )
+ ObjectTableVertexBufferEntryNVX & setFlags( vk::ObjectEntryUsageFlagsNVX flags_ )
{
flags = flags_;
return *this;
}
- ObjectTableVertexBufferEntryNVX & setBuffer( Buffer buffer_ )
+ ObjectTableVertexBufferEntryNVX & setBuffer( vk::Buffer buffer_ )
{
buffer = buffer_;
return *this;
@@ -36195,14 +44174,30 @@
return !operator==( rhs );
}
- ObjectEntryTypeNVX type;
- ObjectEntryUsageFlagsNVX flags;
- Buffer buffer;
+ public:
+ vk::ObjectEntryTypeNVX type;
+ vk::ObjectEntryUsageFlagsNVX flags;
+ vk::Buffer buffer;
};
static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ObjectTableVertexBufferEntryNVX>::value, "struct wrapper is not a standard layout!" );
struct PastPresentationTimingGOOGLE
{
+ PastPresentationTimingGOOGLE()
+ {}
+
+ PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs )
+ {
+ *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this) = rhs;
+ }
+
+ PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs )
+ {
+ *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this) = rhs;
+ return *this;
+ }
+
operator VkPastPresentationTimingGOOGLE const&() const
{
return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>( this );
@@ -36227,6 +44222,7 @@
return !operator==( rhs );
}
+ public:
uint32_t presentID;
uint64_t desiredPresentTime;
uint64_t actualPresentTime;
@@ -36234,21 +44230,49 @@
uint64_t presentMargin;
};
static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PastPresentationTimingGOOGLE>::value, "struct wrapper is not a standard layout!" );
- struct PerformanceConfigurationAcquireInfoINTEL
+ namespace layout
{
- PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationTypeINTEL type_ = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated )
- : type( type_ )
+ struct PerformanceConfigurationAcquireInfoINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated )
+ : type( type_ )
+ {}
+
+ PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
+ }
+
+ PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
+ const void* pNext = nullptr;
+ vk::PerformanceConfigurationTypeINTEL type;
+ };
+ static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PerformanceConfigurationAcquireInfoINTEL : public layout::PerformanceConfigurationAcquireInfoINTEL
+ {
+ VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated )
+ : layout::PerformanceConfigurationAcquireInfoINTEL( type_ )
{}
PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( PerformanceConfigurationAcquireInfoINTEL ) );
- }
+ : layout::PerformanceConfigurationAcquireInfoINTEL( rhs )
+ {}
PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PerformanceConfigurationAcquireInfoINTEL ) );
+ layout::PerformanceConfigurationAcquireInfoINTEL::operator=(rhs);
return *this;
}
@@ -36258,7 +44282,7 @@
return *this;
}
- PerformanceConfigurationAcquireInfoINTEL & setType( PerformanceConfigurationTypeINTEL type_ )
+ PerformanceConfigurationAcquireInfoINTEL & setType( vk::PerformanceConfigurationTypeINTEL type_ )
{
type = type_;
return *this;
@@ -36287,28 +44311,52 @@
}
private:
- StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL;
-
- public:
- const void* pNext = nullptr;
- PerformanceConfigurationTypeINTEL type;
+ using layout::PerformanceConfigurationAcquireInfoINTEL::sType;
};
static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PerformanceConfigurationAcquireInfoINTEL>::value, "struct wrapper is not a standard layout!" );
- struct PerformanceMarkerInfoINTEL
+ namespace layout
{
- PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 )
- : marker( marker_ )
+ struct PerformanceMarkerInfoINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 )
+ : marker( marker_ )
+ {}
+
+ PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
+ }
+
+ PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL;
+ const void* pNext = nullptr;
+ uint64_t marker;
+ };
+ static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PerformanceMarkerInfoINTEL : public layout::PerformanceMarkerInfoINTEL
+ {
+ VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 )
+ : layout::PerformanceMarkerInfoINTEL( marker_ )
{}
PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( PerformanceMarkerInfoINTEL ) );
- }
+ : layout::PerformanceMarkerInfoINTEL( rhs )
+ {}
PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PerformanceMarkerInfoINTEL ) );
+ layout::PerformanceMarkerInfoINTEL::operator=(rhs);
return *this;
}
@@ -36347,32 +44395,60 @@
}
private:
- StructureType sType = StructureType::ePerformanceMarkerInfoINTEL;
-
- public:
- const void* pNext = nullptr;
- uint64_t marker;
+ using layout::PerformanceMarkerInfoINTEL::sType;
};
static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PerformanceMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
- struct PerformanceOverrideInfoINTEL
+ namespace layout
{
- PerformanceOverrideInfoINTEL( PerformanceOverrideTypeINTEL type_ = PerformanceOverrideTypeINTEL::eNullHardware,
- Bool32 enable_ = 0,
- uint64_t parameter_ = 0 )
- : type( type_ )
- , enable( enable_ )
- , parameter( parameter_ )
+ struct PerformanceOverrideInfoINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware,
+ vk::Bool32 enable_ = 0,
+ uint64_t parameter_ = 0 )
+ : type( type_ )
+ , enable( enable_ )
+ , parameter( parameter_ )
+ {}
+
+ PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
+ }
+
+ PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL;
+ const void* pNext = nullptr;
+ vk::PerformanceOverrideTypeINTEL type;
+ vk::Bool32 enable;
+ uint64_t parameter;
+ };
+ static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PerformanceOverrideInfoINTEL : public layout::PerformanceOverrideInfoINTEL
+ {
+ VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware,
+ vk::Bool32 enable_ = 0,
+ uint64_t parameter_ = 0 )
+ : layout::PerformanceOverrideInfoINTEL( type_, enable_, parameter_ )
{}
PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( PerformanceOverrideInfoINTEL ) );
- }
+ : layout::PerformanceOverrideInfoINTEL( rhs )
+ {}
PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PerformanceOverrideInfoINTEL ) );
+ layout::PerformanceOverrideInfoINTEL::operator=(rhs);
return *this;
}
@@ -36382,13 +44458,13 @@
return *this;
}
- PerformanceOverrideInfoINTEL & setType( PerformanceOverrideTypeINTEL type_ )
+ PerformanceOverrideInfoINTEL & setType( vk::PerformanceOverrideTypeINTEL type_ )
{
type = type_;
return *this;
}
- PerformanceOverrideInfoINTEL & setEnable( Bool32 enable_ )
+ PerformanceOverrideInfoINTEL & setEnable( vk::Bool32 enable_ )
{
enable = enable_;
return *this;
@@ -36425,30 +44501,52 @@
}
private:
- StructureType sType = StructureType::ePerformanceOverrideInfoINTEL;
-
- public:
- const void* pNext = nullptr;
- PerformanceOverrideTypeINTEL type;
- Bool32 enable;
- uint64_t parameter;
+ using layout::PerformanceOverrideInfoINTEL::sType;
};
static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PerformanceOverrideInfoINTEL>::value, "struct wrapper is not a standard layout!" );
- struct PerformanceStreamMarkerInfoINTEL
+ namespace layout
{
- PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 )
- : marker( marker_ )
+ struct PerformanceStreamMarkerInfoINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 )
+ : marker( marker_ )
+ {}
+
+ PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
+ }
+
+ PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL;
+ const void* pNext = nullptr;
+ uint32_t marker;
+ };
+ static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PerformanceStreamMarkerInfoINTEL : public layout::PerformanceStreamMarkerInfoINTEL
+ {
+ VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 )
+ : layout::PerformanceStreamMarkerInfoINTEL( marker_ )
{}
PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( PerformanceStreamMarkerInfoINTEL ) );
- }
+ : layout::PerformanceStreamMarkerInfoINTEL( rhs )
+ {}
PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PerformanceStreamMarkerInfoINTEL ) );
+ layout::PerformanceStreamMarkerInfoINTEL::operator=(rhs);
return *this;
}
@@ -36487,13 +44585,10 @@
}
private:
- StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL;
-
- public:
- const void* pNext = nullptr;
- uint32_t marker;
+ using layout::PerformanceStreamMarkerInfoINTEL::sType;
};
static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PerformanceStreamMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
union PerformanceValueDataINTEL
{
@@ -36517,7 +44612,6 @@
valueString = valueString_;
}
-
PerformanceValueDataINTEL & setValue32( uint32_t value32_ )
{
value32 = value32_;
@@ -36536,7 +44630,7 @@
return *this;
}
- PerformanceValueDataINTEL & setValueBool( Bool32 valueBool_ )
+ PerformanceValueDataINTEL & setValueBool( vk::Bool32 valueBool_ )
{
valueBool = valueBool_;
return *this;
@@ -36561,7 +44655,7 @@
uint32_t value32;
uint64_t value64;
float valueFloat;
- Bool32 valueBool;
+ vk::Bool32 valueBool;
const char* valueString;
#else
uint32_t value32;
@@ -36574,30 +44668,30 @@
struct PerformanceValueINTEL
{
- PerformanceValueINTEL( PerformanceValueTypeINTEL type_ = PerformanceValueTypeINTEL::eUint32,
- PerformanceValueDataINTEL data_ = PerformanceValueDataINTEL() )
+ PerformanceValueINTEL( vk::PerformanceValueTypeINTEL type_ = vk::PerformanceValueTypeINTEL::eUint32,
+ vk::PerformanceValueDataINTEL data_ = vk::PerformanceValueDataINTEL() )
: type( type_ )
, data( data_ )
{}
PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PerformanceValueINTEL ) );
+ *reinterpret_cast<VkPerformanceValueINTEL*>(this) = rhs;
}
PerformanceValueINTEL& operator=( VkPerformanceValueINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PerformanceValueINTEL ) );
+ *reinterpret_cast<VkPerformanceValueINTEL*>(this) = rhs;
return *this;
}
- PerformanceValueINTEL & setType( PerformanceValueTypeINTEL type_ )
+ PerformanceValueINTEL & setType( vk::PerformanceValueTypeINTEL type_ )
{
type = type_;
return *this;
}
- PerformanceValueINTEL & setData( PerformanceValueDataINTEL data_ )
+ PerformanceValueINTEL & setData( vk::PerformanceValueDataINTEL data_ )
{
data = data_;
return *this;
@@ -36613,31 +44707,66 @@
return *reinterpret_cast<VkPerformanceValueINTEL*>( this );
}
- PerformanceValueTypeINTEL type;
- PerformanceValueDataINTEL data;
+ public:
+ vk::PerformanceValueTypeINTEL type;
+ vk::PerformanceValueDataINTEL data;
};
static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PerformanceValueINTEL>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDevice16BitStorageFeatures
+ namespace layout
{
- PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = 0,
- Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
- Bool32 storagePushConstant16_ = 0,
- Bool32 storageInputOutput16_ = 0 )
- : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
- , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
- , storagePushConstant16( storagePushConstant16_ )
- , storageInputOutput16( storageInputOutput16_ )
+ struct PhysicalDevice16BitStorageFeatures
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0,
+ vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
+ vk::Bool32 storagePushConstant16_ = 0,
+ vk::Bool32 storageInputOutput16_ = 0 )
+ : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
+ , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
+ , storagePushConstant16( storagePushConstant16_ )
+ , storageInputOutput16( storageInputOutput16_ )
+ {}
+
+ PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
+ }
+
+ PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures;
+ void* pNext = nullptr;
+ vk::Bool32 storageBuffer16BitAccess;
+ vk::Bool32 uniformAndStorageBuffer16BitAccess;
+ vk::Bool32 storagePushConstant16;
+ vk::Bool32 storageInputOutput16;
+ };
+ static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDevice16BitStorageFeatures : public layout::PhysicalDevice16BitStorageFeatures
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0,
+ vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
+ vk::Bool32 storagePushConstant16_ = 0,
+ vk::Bool32 storageInputOutput16_ = 0 )
+ : layout::PhysicalDevice16BitStorageFeatures( storageBuffer16BitAccess_, uniformAndStorageBuffer16BitAccess_, storagePushConstant16_, storageInputOutput16_ )
{}
PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) );
- }
+ : layout::PhysicalDevice16BitStorageFeatures( rhs )
+ {}
PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) );
+ layout::PhysicalDevice16BitStorageFeatures::operator=(rhs);
return *this;
}
@@ -36647,25 +44776,25 @@
return *this;
}
- PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ )
+ PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( vk::Bool32 storageBuffer16BitAccess_ )
{
storageBuffer16BitAccess = storageBuffer16BitAccess_;
return *this;
}
- PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ )
+ PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( vk::Bool32 uniformAndStorageBuffer16BitAccess_ )
{
uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_;
return *this;
}
- PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( Bool32 storagePushConstant16_ )
+ PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( vk::Bool32 storagePushConstant16_ )
{
storagePushConstant16 = storagePushConstant16_;
return *this;
}
- PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( Bool32 storageInputOutput16_ )
+ PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( vk::Bool32 storageInputOutput16_ )
{
storageInputOutput16 = storageInputOutput16_;
return *this;
@@ -36697,35 +44826,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures;
-
- public:
- void* pNext = nullptr;
- Bool32 storageBuffer16BitAccess;
- Bool32 uniformAndStorageBuffer16BitAccess;
- Bool32 storagePushConstant16;
- Bool32 storageInputOutput16;
+ using layout::PhysicalDevice16BitStorageFeatures::sType;
};
static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDevice16BitStorageFeatures>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDevice8BitStorageFeaturesKHR
+ namespace layout
{
- PhysicalDevice8BitStorageFeaturesKHR( Bool32 storageBuffer8BitAccess_ = 0,
- Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
- Bool32 storagePushConstant8_ = 0 )
- : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
- , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
- , storagePushConstant8( storagePushConstant8_ )
+ struct PhysicalDevice8BitStorageFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0,
+ vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
+ vk::Bool32 storagePushConstant8_ = 0 )
+ : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
+ , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
+ , storagePushConstant8( storagePushConstant8_ )
+ {}
+
+ PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 storageBuffer8BitAccess;
+ vk::Bool32 uniformAndStorageBuffer8BitAccess;
+ vk::Bool32 storagePushConstant8;
+ };
+ static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDevice8BitStorageFeaturesKHR : public layout::PhysicalDevice8BitStorageFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0,
+ vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
+ vk::Bool32 storagePushConstant8_ = 0 )
+ : layout::PhysicalDevice8BitStorageFeaturesKHR( storageBuffer8BitAccess_, uniformAndStorageBuffer8BitAccess_, storagePushConstant8_ )
{}
PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
- }
+ : layout::PhysicalDevice8BitStorageFeaturesKHR( rhs )
+ {}
PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
+ layout::PhysicalDevice8BitStorageFeaturesKHR::operator=(rhs);
return *this;
}
@@ -36735,19 +44889,19 @@
return *this;
}
- PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ )
+ PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess( vk::Bool32 storageBuffer8BitAccess_ )
{
storageBuffer8BitAccess = storageBuffer8BitAccess_;
return *this;
}
- PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ )
+ PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess( vk::Bool32 uniformAndStorageBuffer8BitAccess_ )
{
uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_;
return *this;
}
- PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8( Bool32 storagePushConstant8_ )
+ PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8( vk::Bool32 storagePushConstant8_ )
{
storagePushConstant8 = storagePushConstant8_;
return *this;
@@ -36778,30 +44932,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR;
-
- public:
- void* pNext = nullptr;
- Bool32 storageBuffer8BitAccess;
- Bool32 uniformAndStorageBuffer8BitAccess;
- Bool32 storagePushConstant8;
+ using layout::PhysicalDevice8BitStorageFeaturesKHR::sType;
};
static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDevice8BitStorageFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceASTCDecodeFeaturesEXT
+ namespace layout
{
- PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 )
- : decodeModeSharedExponent( decodeModeSharedExponent_ )
+ struct PhysicalDeviceASTCDecodeFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 )
+ : decodeModeSharedExponent( decodeModeSharedExponent_ )
+ {}
+
+ PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 decodeModeSharedExponent;
+ };
+ static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceASTCDecodeFeaturesEXT : public layout::PhysicalDeviceASTCDecodeFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 )
+ : layout::PhysicalDeviceASTCDecodeFeaturesEXT( decodeModeSharedExponent_ )
{}
PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceASTCDecodeFeaturesEXT( rhs )
+ {}
PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
+ layout::PhysicalDeviceASTCDecodeFeaturesEXT::operator=(rhs);
return *this;
}
@@ -36811,7 +44987,7 @@
return *this;
}
- PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ )
+ PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( vk::Bool32 decodeModeSharedExponent_ )
{
decodeModeSharedExponent = decodeModeSharedExponent_;
return *this;
@@ -36840,28 +45016,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 decodeModeSharedExponent;
+ using layout::PhysicalDeviceASTCDecodeFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceASTCDecodeFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
+ namespace layout
{
- PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
- : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
+ struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 )
+ : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
+ {}
+
+ PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 advancedBlendCoherentOperations;
+ };
+ static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT : public layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 )
+ : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( advancedBlendCoherentOperations_ )
{}
PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( rhs )
+ {}
PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) );
+ layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(rhs);
return *this;
}
@@ -36871,7 +45071,7 @@
return *this;
}
- PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ )
+ PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( vk::Bool32 advancedBlendCoherentOperations_ )
{
advancedBlendCoherentOperations = advancedBlendCoherentOperations_;
return *this;
@@ -36900,16 +45100,59 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 advancedBlendCoherentOperations;
+ using layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+ {}
+
+ PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t advancedBlendMaxColorAttachments;
+ vk::Bool32 advancedBlendIndependentBlend;
+ vk::Bool32 advancedBlendNonPremultipliedSrcColor;
+ vk::Bool32 advancedBlendNonPremultipliedDstColor;
+ vk::Bool32 advancedBlendCorrelatedOverlap;
+ vk::Bool32 advancedBlendAllOperations;
+ };
+ static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT : public layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT
+ {
+ PhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+ : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+ {}
+
+ PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this );
@@ -36938,37 +45181,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t advancedBlendMaxColorAttachments;
- Bool32 advancedBlendIndependentBlend;
- Bool32 advancedBlendNonPremultipliedSrcColor;
- Bool32 advancedBlendNonPremultipliedDstColor;
- Bool32 advancedBlendCorrelatedOverlap;
- Bool32 advancedBlendAllOperations;
+ using layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
+ namespace layout
{
- PhysicalDeviceBufferDeviceAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = 0,
- Bool32 bufferDeviceAddressCaptureReplay_ = 0,
- Bool32 bufferDeviceAddressMultiDevice_ = 0 )
- : bufferDeviceAddress( bufferDeviceAddress_ )
- , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
- , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
+ struct PhysicalDeviceBufferDeviceAddressFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0,
+ vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0,
+ vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 )
+ : bufferDeviceAddress( bufferDeviceAddress_ )
+ , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ )
+ , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ )
+ {}
+
+ PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 bufferDeviceAddress;
+ vk::Bool32 bufferDeviceAddressCaptureReplay;
+ vk::Bool32 bufferDeviceAddressMultiDevice;
+ };
+ static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceBufferDeviceAddressFeaturesEXT : public layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0,
+ vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0,
+ vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 )
+ : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( bufferDeviceAddress_, bufferDeviceAddressCaptureReplay_, bufferDeviceAddressMultiDevice_ )
{}
PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( rhs )
+ {}
PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) );
+ layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(rhs);
return *this;
}
@@ -36978,19 +45244,19 @@
return *this;
}
- PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ )
+ PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( vk::Bool32 bufferDeviceAddress_ )
{
bufferDeviceAddress = bufferDeviceAddress_;
return *this;
}
- PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ )
+ PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( vk::Bool32 bufferDeviceAddressCaptureReplay_ )
{
bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_;
return *this;
}
- PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ )
+ PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( vk::Bool32 bufferDeviceAddressMultiDevice_ )
{
bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_;
return *this;
@@ -37021,32 +45287,140 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 bufferDeviceAddress;
- Bool32 bufferDeviceAddressCaptureReplay;
- Bool32 bufferDeviceAddressMultiDevice;
+ using layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceBufferDeviceAddressFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
+ namespace layout
{
- PhysicalDeviceComputeShaderDerivativesFeaturesNV( Bool32 computeDerivativeGroupQuads_ = 0,
- Bool32 computeDerivativeGroupLinear_ = 0 )
- : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
- , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
+ struct PhysicalDeviceCoherentMemoryFeaturesAMD
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 )
+ : deviceCoherentMemory( deviceCoherentMemory_ )
+ {}
+
+ PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
+ }
+
+ PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD;
+ void* pNext = nullptr;
+ vk::Bool32 deviceCoherentMemory;
+ };
+ static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceCoherentMemoryFeaturesAMD : public layout::PhysicalDeviceCoherentMemoryFeaturesAMD
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 )
+ : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( deviceCoherentMemory_ )
+ {}
+
+ PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+ : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( rhs )
+ {}
+
+ PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs )
+ {
+ layout::PhysicalDeviceCoherentMemoryFeaturesAMD::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceCoherentMemoryFeaturesAMD & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceCoherentMemoryFeaturesAMD & setDeviceCoherentMemory( vk::Bool32 deviceCoherentMemory_ )
+ {
+ deviceCoherentMemory = deviceCoherentMemory_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this );
+ }
+
+ operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this );
+ }
+
+ bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( deviceCoherentMemory == rhs.deviceCoherentMemory );
+ }
+
+ bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceCoherentMemoryFeaturesAMD::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceCoherentMemoryFeaturesAMD>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceComputeShaderDerivativesFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0,
+ vk::Bool32 computeDerivativeGroupLinear_ = 0 )
+ : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
+ , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
+ {}
+
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 computeDerivativeGroupQuads;
+ vk::Bool32 computeDerivativeGroupLinear;
+ };
+ static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceComputeShaderDerivativesFeaturesNV : public layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0,
+ vk::Bool32 computeDerivativeGroupLinear_ = 0 )
+ : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( computeDerivativeGroupQuads_, computeDerivativeGroupLinear_ )
{}
PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
- }
+ : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( rhs )
+ {}
PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) );
+ layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(rhs);
return *this;
}
@@ -37056,13 +45430,13 @@
return *this;
}
- PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads( vk::Bool32 computeDerivativeGroupQuads_ )
{
computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
return *this;
}
- PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ )
+ PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear( vk::Bool32 computeDerivativeGroupLinear_ )
{
computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
return *this;
@@ -37092,31 +45466,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 computeDerivativeGroupQuads;
- Bool32 computeDerivativeGroupLinear;
+ using layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceComputeShaderDerivativesFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceConditionalRenderingFeaturesEXT
+ namespace layout
{
- PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = 0,
- Bool32 inheritedConditionalRendering_ = 0 )
- : conditionalRendering( conditionalRendering_ )
- , inheritedConditionalRendering( inheritedConditionalRendering_ )
+ struct PhysicalDeviceConditionalRenderingFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0,
+ vk::Bool32 inheritedConditionalRendering_ = 0 )
+ : conditionalRendering( conditionalRendering_ )
+ , inheritedConditionalRendering( inheritedConditionalRendering_ )
+ {}
+
+ PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 conditionalRendering;
+ vk::Bool32 inheritedConditionalRendering;
+ };
+ static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceConditionalRenderingFeaturesEXT : public layout::PhysicalDeviceConditionalRenderingFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0,
+ vk::Bool32 inheritedConditionalRendering_ = 0 )
+ : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( conditionalRendering_, inheritedConditionalRendering_ )
{}
PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( rhs )
+ {}
PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) );
+ layout::PhysicalDeviceConditionalRenderingFeaturesEXT::operator=(rhs);
return *this;
}
@@ -37126,13 +45525,13 @@
return *this;
}
- PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( Bool32 conditionalRendering_ )
+ PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( vk::Bool32 conditionalRendering_ )
{
conditionalRendering = conditionalRendering_;
return *this;
}
- PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ )
+ PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( vk::Bool32 inheritedConditionalRendering_ )
{
inheritedConditionalRendering = inheritedConditionalRendering_;
return *this;
@@ -37162,17 +45561,62 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 conditionalRendering;
- Bool32 inheritedConditionalRendering;
+ using layout::PhysicalDeviceConditionalRenderingFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceConditionalRenderingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceConservativeRasterizationPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceConservativeRasterizationPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceConservativeRasterizationPropertiesEXT()
+ {}
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
+ void* pNext = nullptr;
+ float primitiveOverestimationSize;
+ float maxExtraPrimitiveOverestimationSize;
+ float extraPrimitiveOverestimationSizeGranularity;
+ vk::Bool32 primitiveUnderestimation;
+ vk::Bool32 conservativePointAndLineRasterization;
+ vk::Bool32 degenerateTrianglesRasterized;
+ vk::Bool32 degenerateLinesRasterized;
+ vk::Bool32 fullyCoveredFragmentShaderInputVariable;
+ vk::Bool32 conservativeRasterizationPostDepthCoverage;
+ };
+ static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceConservativeRasterizationPropertiesEXT : public layout::PhysicalDeviceConservativeRasterizationPropertiesEXT
+ {
+ PhysicalDeviceConservativeRasterizationPropertiesEXT()
+ : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT()
+ {}
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this );
@@ -37204,38 +45648,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- float primitiveOverestimationSize;
- float maxExtraPrimitiveOverestimationSize;
- float extraPrimitiveOverestimationSizeGranularity;
- Bool32 primitiveUnderestimation;
- Bool32 conservativePointAndLineRasterization;
- Bool32 degenerateTrianglesRasterized;
- Bool32 degenerateLinesRasterized;
- Bool32 fullyCoveredFragmentShaderInputVariable;
- Bool32 conservativeRasterizationPostDepthCoverage;
+ using layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceConservativeRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceCooperativeMatrixFeaturesNV
+ namespace layout
{
- PhysicalDeviceCooperativeMatrixFeaturesNV( Bool32 cooperativeMatrix_ = 0,
- Bool32 cooperativeMatrixRobustBufferAccess_ = 0 )
- : cooperativeMatrix( cooperativeMatrix_ )
- , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
+ struct PhysicalDeviceCooperativeMatrixFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0,
+ vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 )
+ : cooperativeMatrix( cooperativeMatrix_ )
+ , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ )
+ {}
+
+ PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 cooperativeMatrix;
+ vk::Bool32 cooperativeMatrixRobustBufferAccess;
+ };
+ static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceCooperativeMatrixFeaturesNV : public layout::PhysicalDeviceCooperativeMatrixFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0,
+ vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 )
+ : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( cooperativeMatrix_, cooperativeMatrixRobustBufferAccess_ )
{}
PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) );
- }
+ : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( rhs )
+ {}
PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) );
+ layout::PhysicalDeviceCooperativeMatrixFeaturesNV::operator=(rhs);
return *this;
}
@@ -37245,13 +45707,13 @@
return *this;
}
- PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( Bool32 cooperativeMatrix_ )
+ PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( vk::Bool32 cooperativeMatrix_ )
{
cooperativeMatrix = cooperativeMatrix_;
return *this;
}
- PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ )
+ PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( vk::Bool32 cooperativeMatrixRobustBufferAccess_ )
{
cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_;
return *this;
@@ -37281,17 +45743,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 cooperativeMatrix;
- Bool32 cooperativeMatrixRobustBufferAccess;
+ using layout::PhysicalDeviceCooperativeMatrixFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceCooperativeMatrixPropertiesNV
+ namespace layout
{
+ struct PhysicalDeviceCooperativeMatrixPropertiesNV
+ {
+ protected:
+ PhysicalDeviceCooperativeMatrixPropertiesNV()
+ {}
+
+ PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
+ void* pNext = nullptr;
+ vk::ShaderStageFlags cooperativeMatrixSupportedStages;
+ };
+ static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceCooperativeMatrixPropertiesNV : public layout::PhysicalDeviceCooperativeMatrixPropertiesNV
+ {
+ PhysicalDeviceCooperativeMatrixPropertiesNV()
+ : layout::PhysicalDeviceCooperativeMatrixPropertiesNV()
+ {}
+
+ PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs )
+ : layout::PhysicalDeviceCooperativeMatrixPropertiesNV( rhs )
+ {}
+
+ PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs )
+ {
+ layout::PhysicalDeviceCooperativeMatrixPropertiesNV::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>( this );
@@ -37315,28 +45814,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV;
-
- public:
- void* pNext = nullptr;
- ShaderStageFlags cooperativeMatrixSupportedStages;
+ using layout::PhysicalDeviceCooperativeMatrixPropertiesNV::sType;
};
static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceCornerSampledImageFeaturesNV
+ namespace layout
{
- PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = 0 )
- : cornerSampledImage( cornerSampledImage_ )
+ struct PhysicalDeviceCornerSampledImageFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 )
+ : cornerSampledImage( cornerSampledImage_ )
+ {}
+
+ PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 cornerSampledImage;
+ };
+ static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceCornerSampledImageFeaturesNV : public layout::PhysicalDeviceCornerSampledImageFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 )
+ : layout::PhysicalDeviceCornerSampledImageFeaturesNV( cornerSampledImage_ )
{}
PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
- }
+ : layout::PhysicalDeviceCornerSampledImageFeaturesNV( rhs )
+ {}
PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
+ layout::PhysicalDeviceCornerSampledImageFeaturesNV::operator=(rhs);
return *this;
}
@@ -37346,7 +45869,7 @@
return *this;
}
- PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( Bool32 cornerSampledImage_ )
+ PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( vk::Bool32 cornerSampledImage_ )
{
cornerSampledImage = cornerSampledImage_;
return *this;
@@ -37375,28 +45898,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 cornerSampledImage;
+ using layout::PhysicalDeviceCornerSampledImageFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceCornerSampledImageFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceCoverageReductionModeFeaturesNV
+ namespace layout
{
- PhysicalDeviceCoverageReductionModeFeaturesNV( Bool32 coverageReductionMode_ = 0 )
- : coverageReductionMode( coverageReductionMode_ )
+ struct PhysicalDeviceCoverageReductionModeFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 )
+ : coverageReductionMode( coverageReductionMode_ )
+ {}
+
+ PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 coverageReductionMode;
+ };
+ static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceCoverageReductionModeFeaturesNV : public layout::PhysicalDeviceCoverageReductionModeFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 )
+ : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( coverageReductionMode_ )
{}
PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) );
- }
+ : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( rhs )
+ {}
PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) );
+ layout::PhysicalDeviceCoverageReductionModeFeaturesNV::operator=(rhs);
return *this;
}
@@ -37406,7 +45953,7 @@
return *this;
}
- PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( Bool32 coverageReductionMode_ )
+ PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( vk::Bool32 coverageReductionMode_ )
{
coverageReductionMode = coverageReductionMode_;
return *this;
@@ -37435,28 +45982,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 coverageReductionMode;
+ using layout::PhysicalDeviceCoverageReductionModeFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceCoverageReductionModeFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
+ namespace layout
{
- PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( Bool32 dedicatedAllocationImageAliasing_ = 0 )
- : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
+ struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 )
+ : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ )
+ {}
+
+ PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 dedicatedAllocationImageAliasing;
+ };
+ static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : public layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 )
+ : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( dedicatedAllocationImageAliasing_ )
{}
PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) );
- }
+ : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( rhs )
+ {}
PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) );
+ layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(rhs);
return *this;
}
@@ -37466,7 +46037,7 @@
return *this;
}
- PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ )
+ PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setDedicatedAllocationImageAliasing( vk::Bool32 dedicatedAllocationImageAliasing_ )
{
dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_;
return *this;
@@ -37495,28 +46066,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 dedicatedAllocationImageAliasing;
+ using layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDepthClipEnableFeaturesEXT
+ namespace layout
{
- PhysicalDeviceDepthClipEnableFeaturesEXT( Bool32 depthClipEnable_ = 0 )
- : depthClipEnable( depthClipEnable_ )
+ struct PhysicalDeviceDepthClipEnableFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 )
+ : depthClipEnable( depthClipEnable_ )
+ {}
+
+ PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 depthClipEnable;
+ };
+ static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDepthClipEnableFeaturesEXT : public layout::PhysicalDeviceDepthClipEnableFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 )
+ : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( depthClipEnable_ )
{}
PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( rhs )
+ {}
PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) );
+ layout::PhysicalDeviceDepthClipEnableFeaturesEXT::operator=(rhs);
return *this;
}
@@ -37526,7 +46121,7 @@
return *this;
}
- PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( Bool32 depthClipEnable_ )
+ PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( vk::Bool32 depthClipEnable_ )
{
depthClipEnable = depthClipEnable_;
return *this;
@@ -37555,16 +46150,57 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 depthClipEnable;
+ using layout::PhysicalDeviceDepthClipEnableFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDepthClipEnableFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDepthStencilResolvePropertiesKHR
+ namespace layout
{
+ struct PhysicalDeviceDepthStencilResolvePropertiesKHR
+ {
+ protected:
+ PhysicalDeviceDepthStencilResolvePropertiesKHR()
+ {}
+
+ PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR;
+ void* pNext = nullptr;
+ vk::ResolveModeFlagsKHR supportedDepthResolveModes;
+ vk::ResolveModeFlagsKHR supportedStencilResolveModes;
+ vk::Bool32 independentResolveNone;
+ vk::Bool32 independentResolve;
+ };
+ static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDepthStencilResolvePropertiesKHR : public layout::PhysicalDeviceDepthStencilResolvePropertiesKHR
+ {
+ PhysicalDeviceDepthStencilResolvePropertiesKHR()
+ : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR()
+ {}
+
+ PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs )
+ : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR( rhs )
+ {}
+
+ PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs )
+ {
+ layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceDepthStencilResolvePropertiesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>( this );
@@ -37591,69 +46227,128 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR;
-
- public:
- void* pNext = nullptr;
- ResolveModeFlagsKHR supportedDepthResolveModes;
- ResolveModeFlagsKHR supportedStencilResolveModes;
- Bool32 independentResolveNone;
- Bool32 independentResolve;
+ using layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::sType;
};
static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDepthStencilResolvePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDescriptorIndexingFeaturesEXT
+ namespace layout
{
- PhysicalDeviceDescriptorIndexingFeaturesEXT( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
- Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
- Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
- Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
- Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
- Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
- Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
- Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
- Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
- Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
- Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
- Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
- Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
- Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
- Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
- Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
- Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
- Bool32 descriptorBindingPartiallyBound_ = 0,
- Bool32 descriptorBindingVariableDescriptorCount_ = 0,
- Bool32 runtimeDescriptorArray_ = 0 )
- : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ )
- , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ )
- , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ )
- , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ )
- , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ )
- , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ )
- , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ )
- , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ )
- , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ )
- , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ )
- , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ )
- , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ )
- , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ )
- , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ )
- , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ )
- , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ )
- , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ )
- , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ )
- , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ )
- , runtimeDescriptorArray( runtimeDescriptorArray_ )
+ struct PhysicalDeviceDescriptorIndexingFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
+ vk::Bool32 descriptorBindingPartiallyBound_ = 0,
+ vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0,
+ vk::Bool32 runtimeDescriptorArray_ = 0 )
+ : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ )
+ , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ )
+ , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ )
+ , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ )
+ , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ )
+ , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ )
+ , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ )
+ , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ )
+ , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ )
+ , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ )
+ , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ )
+ , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ )
+ , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ )
+ , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ )
+ , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ )
+ , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ )
+ , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ )
+ , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ )
+ , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ )
+ , runtimeDescriptorArray( runtimeDescriptorArray_ )
+ {}
+
+ PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 shaderInputAttachmentArrayDynamicIndexing;
+ vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing;
+ vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing;
+ vk::Bool32 shaderUniformBufferArrayNonUniformIndexing;
+ vk::Bool32 shaderSampledImageArrayNonUniformIndexing;
+ vk::Bool32 shaderStorageBufferArrayNonUniformIndexing;
+ vk::Bool32 shaderStorageImageArrayNonUniformIndexing;
+ vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing;
+ vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing;
+ vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing;
+ vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind;
+ vk::Bool32 descriptorBindingSampledImageUpdateAfterBind;
+ vk::Bool32 descriptorBindingStorageImageUpdateAfterBind;
+ vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind;
+ vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
+ vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
+ vk::Bool32 descriptorBindingUpdateUnusedWhilePending;
+ vk::Bool32 descriptorBindingPartiallyBound;
+ vk::Bool32 descriptorBindingVariableDescriptorCount;
+ vk::Bool32 runtimeDescriptorArray;
+ };
+ static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDescriptorIndexingFeaturesEXT : public layout::PhysicalDeviceDescriptorIndexingFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
+ vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
+ vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
+ vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
+ vk::Bool32 descriptorBindingPartiallyBound_ = 0,
+ vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0,
+ vk::Bool32 runtimeDescriptorArray_ = 0 )
+ : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( shaderInputAttachmentArrayDynamicIndexing_, shaderUniformTexelBufferArrayDynamicIndexing_, shaderStorageTexelBufferArrayDynamicIndexing_, shaderUniformBufferArrayNonUniformIndexing_, shaderSampledImageArrayNonUniformIndexing_, shaderStorageBufferArrayNonUniformIndexing_, shaderStorageImageArrayNonUniformIndexing_, shaderInputAttachmentArrayNonUniformIndexing_, shaderUniformTexelBufferArrayNonUniformIndexing_, shaderStorageTexelBufferArrayNonUniformIndexing_, descriptorBindingUniformBufferUpdateAfterBind_, descriptorBindingSampledImageUpdateAfterBind_, descriptorBindingStorageImageUpdateAfterBind_, descriptorBindingStorageBufferUpdateAfterBind_, descriptorBindingUniformTexelBufferUpdateAfterBind_, descriptorBindingStorageTexelBufferUpdateAfterBind_, descriptorBindingUpdateUnusedWhilePending_, descriptorBindingPartiallyBound_, descriptorBindingVariableDescriptorCount_, runtimeDescriptorArray_ )
{}
PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( rhs )
+ {}
PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) );
+ layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::operator=(rhs);
return *this;
}
@@ -37663,121 +46358,121 @@
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayDynamicIndexing( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ )
{
shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayDynamicIndexing( vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ )
{
shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayDynamicIndexing( vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ )
{
shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformBufferArrayNonUniformIndexing( vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ )
{
shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderSampledImageArrayNonUniformIndexing( vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ )
{
shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageBufferArrayNonUniformIndexing( vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ )
{
shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageImageArrayNonUniformIndexing( vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ )
{
shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayNonUniformIndexing( vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ )
{
shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayNonUniformIndexing( vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ )
{
shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayNonUniformIndexing( vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ )
{
shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformBufferUpdateAfterBind( vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ )
{
descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingSampledImageUpdateAfterBind( vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ )
{
descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageImageUpdateAfterBind( vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ )
{
descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageBufferUpdateAfterBind( vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ )
{
descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformTexelBufferUpdateAfterBind( vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ )
{
descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageTexelBufferUpdateAfterBind( vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ )
{
descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUpdateUnusedWhilePending( vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ )
{
descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingPartiallyBound( vk::Bool32 descriptorBindingPartiallyBound_ )
{
descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingVariableDescriptorCount( vk::Bool32 descriptorBindingVariableDescriptorCount_ )
{
descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_;
return *this;
}
- PhysicalDeviceDescriptorIndexingFeaturesEXT & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ )
+ PhysicalDeviceDescriptorIndexingFeaturesEXT & setRuntimeDescriptorArray( vk::Bool32 runtimeDescriptorArray_ )
{
runtimeDescriptorArray = runtimeDescriptorArray_;
return *this;
@@ -37825,35 +46520,76 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 shaderInputAttachmentArrayDynamicIndexing;
- Bool32 shaderUniformTexelBufferArrayDynamicIndexing;
- Bool32 shaderStorageTexelBufferArrayDynamicIndexing;
- Bool32 shaderUniformBufferArrayNonUniformIndexing;
- Bool32 shaderSampledImageArrayNonUniformIndexing;
- Bool32 shaderStorageBufferArrayNonUniformIndexing;
- Bool32 shaderStorageImageArrayNonUniformIndexing;
- Bool32 shaderInputAttachmentArrayNonUniformIndexing;
- Bool32 shaderUniformTexelBufferArrayNonUniformIndexing;
- Bool32 shaderStorageTexelBufferArrayNonUniformIndexing;
- Bool32 descriptorBindingUniformBufferUpdateAfterBind;
- Bool32 descriptorBindingSampledImageUpdateAfterBind;
- Bool32 descriptorBindingStorageImageUpdateAfterBind;
- Bool32 descriptorBindingStorageBufferUpdateAfterBind;
- Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
- Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
- Bool32 descriptorBindingUpdateUnusedWhilePending;
- Bool32 descriptorBindingPartiallyBound;
- Bool32 descriptorBindingVariableDescriptorCount;
- Bool32 runtimeDescriptorArray;
+ using layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDescriptorIndexingPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceDescriptorIndexingPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceDescriptorIndexingPropertiesEXT()
+ {}
+
+ PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+ vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative;
+ vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative;
+ vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative;
+ vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative;
+ vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+ vk::Bool32 robustBufferAccessUpdateAfterBind;
+ vk::Bool32 quadDivergentImplicitLod;
+ uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+ uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+ uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+ uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+ uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+ uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+ uint32_t maxPerStageUpdateAfterBindResources;
+ uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+ uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+ uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+ uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+ uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+ uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+ uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+ uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+ };
+ static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDescriptorIndexingPropertiesEXT : public layout::PhysicalDeviceDescriptorIndexingPropertiesEXT
+ {
+ PhysicalDeviceDescriptorIndexingPropertiesEXT()
+ : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT()
+ {}
+
+ PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceDescriptorIndexingPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>( this );
@@ -37899,38 +46635,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t maxUpdateAfterBindDescriptorsInAllPools;
- Bool32 shaderUniformBufferArrayNonUniformIndexingNative;
- Bool32 shaderSampledImageArrayNonUniformIndexingNative;
- Bool32 shaderStorageBufferArrayNonUniformIndexingNative;
- Bool32 shaderStorageImageArrayNonUniformIndexingNative;
- Bool32 shaderInputAttachmentArrayNonUniformIndexingNative;
- Bool32 robustBufferAccessUpdateAfterBind;
- Bool32 quadDivergentImplicitLod;
- uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
- uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
- uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
- uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
- uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
- uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
- uint32_t maxPerStageUpdateAfterBindResources;
- uint32_t maxDescriptorSetUpdateAfterBindSamplers;
- uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
- uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
- uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
- uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
- uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
- uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
- uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+ using layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDiscardRectanglePropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceDiscardRectanglePropertiesEXT
+ {
+ protected:
+ PhysicalDeviceDiscardRectanglePropertiesEXT()
+ {}
+
+ PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t maxDiscardRectangles;
+ };
+ static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDiscardRectanglePropertiesEXT : public layout::PhysicalDeviceDiscardRectanglePropertiesEXT
+ {
+ PhysicalDeviceDiscardRectanglePropertiesEXT()
+ : layout::PhysicalDeviceDiscardRectanglePropertiesEXT()
+ {}
+
+ PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+ : layout::PhysicalDeviceDiscardRectanglePropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceDiscardRectanglePropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this );
@@ -37954,16 +46706,57 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t maxDiscardRectangles;
+ using layout::PhysicalDeviceDiscardRectanglePropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDiscardRectanglePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceDriverPropertiesKHR
+ namespace layout
{
+ struct PhysicalDeviceDriverPropertiesKHR
+ {
+ protected:
+ PhysicalDeviceDriverPropertiesKHR()
+ {}
+
+ PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
+ void* pNext = nullptr;
+ vk::DriverIdKHR driverID;
+ char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
+ char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
+ vk::ConformanceVersionKHR conformanceVersion;
+ };
+ static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceDriverPropertiesKHR : public layout::PhysicalDeviceDriverPropertiesKHR
+ {
+ PhysicalDeviceDriverPropertiesKHR()
+ : layout::PhysicalDeviceDriverPropertiesKHR()
+ {}
+
+ PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs )
+ : layout::PhysicalDeviceDriverPropertiesKHR( rhs )
+ {}
+
+ PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs )
+ {
+ layout::PhysicalDeviceDriverPropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceDriverPropertiesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR*>( this );
@@ -37990,31 +46783,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR;
-
- public:
- void* pNext = nullptr;
- DriverIdKHR driverID;
- char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
- char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
- ConformanceVersionKHR conformanceVersion;
+ using layout::PhysicalDeviceDriverPropertiesKHR::sType;
};
static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceDriverPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceExclusiveScissorFeaturesNV
+ namespace layout
{
- PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = 0 )
- : exclusiveScissor( exclusiveScissor_ )
+ struct PhysicalDeviceExclusiveScissorFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 )
+ : exclusiveScissor( exclusiveScissor_ )
+ {}
+
+ PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 exclusiveScissor;
+ };
+ static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceExclusiveScissorFeaturesNV : public layout::PhysicalDeviceExclusiveScissorFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 )
+ : layout::PhysicalDeviceExclusiveScissorFeaturesNV( exclusiveScissor_ )
{}
PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
- }
+ : layout::PhysicalDeviceExclusiveScissorFeaturesNV( rhs )
+ {}
PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
+ layout::PhysicalDeviceExclusiveScissorFeaturesNV::operator=(rhs);
return *this;
}
@@ -38024,7 +46838,7 @@
return *this;
}
- PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( Bool32 exclusiveScissor_ )
+ PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( vk::Bool32 exclusiveScissor_ )
{
exclusiveScissor = exclusiveScissor_;
return *this;
@@ -38053,32 +46867,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 exclusiveScissor;
+ using layout::PhysicalDeviceExclusiveScissorFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceExclusiveScissorFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceExternalBufferInfo
+ namespace layout
{
- PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = BufferCreateFlags(),
- BufferUsageFlags usage_ = BufferUsageFlags(),
- ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : flags( flags_ )
- , usage( usage_ )
- , handleType( handleType_ )
+ struct PhysicalDeviceExternalBufferInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+ vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+ vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : flags( flags_ )
+ , usage( usage_ )
+ , handleType( handleType_ )
+ {}
+
+ PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
+ }
+
+ PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
+ const void* pNext = nullptr;
+ vk::BufferCreateFlags flags;
+ vk::BufferUsageFlags usage;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceExternalBufferInfo : public layout::PhysicalDeviceExternalBufferInfo
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(),
+ vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(),
+ vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : layout::PhysicalDeviceExternalBufferInfo( flags_, usage_, handleType_ )
{}
PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
- }
+ : layout::PhysicalDeviceExternalBufferInfo( rhs )
+ {}
PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
+ layout::PhysicalDeviceExternalBufferInfo::operator=(rhs);
return *this;
}
@@ -38088,19 +46930,19 @@
return *this;
}
- PhysicalDeviceExternalBufferInfo & setFlags( BufferCreateFlags flags_ )
+ PhysicalDeviceExternalBufferInfo & setFlags( vk::BufferCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- PhysicalDeviceExternalBufferInfo & setUsage( BufferUsageFlags usage_ )
+ PhysicalDeviceExternalBufferInfo & setUsage( vk::BufferUsageFlags usage_ )
{
usage = usage_;
return *this;
}
- PhysicalDeviceExternalBufferInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ PhysicalDeviceExternalBufferInfo & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -38131,30 +46973,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo;
-
- public:
- const void* pNext = nullptr;
- BufferCreateFlags flags;
- BufferUsageFlags usage;
- ExternalMemoryHandleTypeFlagBits handleType;
+ using layout::PhysicalDeviceExternalBufferInfo::sType;
};
static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceExternalBufferInfo>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceExternalFenceInfo
+ namespace layout
{
- PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd )
- : handleType( handleType_ )
+ struct PhysicalDeviceExternalFenceInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : handleType( handleType_ )
+ {}
+
+ PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
+ }
+
+ PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
+ const void* pNext = nullptr;
+ vk::ExternalFenceHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceExternalFenceInfo : public layout::PhysicalDeviceExternalFenceInfo
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd )
+ : layout::PhysicalDeviceExternalFenceInfo( handleType_ )
{}
PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
- }
+ : layout::PhysicalDeviceExternalFenceInfo( rhs )
+ {}
PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
+ layout::PhysicalDeviceExternalFenceInfo::operator=(rhs);
return *this;
}
@@ -38164,7 +47028,7 @@
return *this;
}
- PhysicalDeviceExternalFenceInfo & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
+ PhysicalDeviceExternalFenceInfo & setHandleType( vk::ExternalFenceHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -38193,28 +47057,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalFenceHandleTypeFlagBits handleType;
+ using layout::PhysicalDeviceExternalFenceInfo::sType;
};
static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceExternalFenceInfo>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceExternalImageFormatInfo
+ namespace layout
{
- PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
- : handleType( handleType_ )
+ struct PhysicalDeviceExternalImageFormatInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : handleType( handleType_ )
+ {}
+
+ PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
+ }
+
+ PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
+ const void* pNext = nullptr;
+ vk::ExternalMemoryHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceExternalImageFormatInfo : public layout::PhysicalDeviceExternalImageFormatInfo
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
+ : layout::PhysicalDeviceExternalImageFormatInfo( handleType_ )
{}
PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
- }
+ : layout::PhysicalDeviceExternalImageFormatInfo( rhs )
+ {}
PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
+ layout::PhysicalDeviceExternalImageFormatInfo::operator=(rhs);
return *this;
}
@@ -38224,7 +47112,7 @@
return *this;
}
- PhysicalDeviceExternalImageFormatInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
+ PhysicalDeviceExternalImageFormatInfo & setHandleType( vk::ExternalMemoryHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -38253,16 +47141,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalMemoryHandleTypeFlagBits handleType;
+ using layout::PhysicalDeviceExternalImageFormatInfo::sType;
};
static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceExternalImageFormatInfo>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceExternalMemoryHostPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceExternalMemoryHostPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceExternalMemoryHostPropertiesEXT()
+ {}
+
+ PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
+ void* pNext = nullptr;
+ vk::DeviceSize minImportedHostPointerAlignment;
+ };
+ static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceExternalMemoryHostPropertiesEXT : public layout::PhysicalDeviceExternalMemoryHostPropertiesEXT
+ {
+ PhysicalDeviceExternalMemoryHostPropertiesEXT()
+ : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT()
+ {}
+
+ PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this );
@@ -38286,28 +47212,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- DeviceSize minImportedHostPointerAlignment;
+ using layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceExternalMemoryHostPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceExternalSemaphoreInfo
+ namespace layout
{
- PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
- : handleType( handleType_ )
+ struct PhysicalDeviceExternalSemaphoreInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : handleType( handleType_ )
+ {}
+
+ PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
+ }
+
+ PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
+ const void* pNext = nullptr;
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceExternalSemaphoreInfo : public layout::PhysicalDeviceExternalSemaphoreInfo
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : layout::PhysicalDeviceExternalSemaphoreInfo( handleType_ )
{}
PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
- }
+ : layout::PhysicalDeviceExternalSemaphoreInfo( rhs )
+ {}
PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
+ layout::PhysicalDeviceExternalSemaphoreInfo::operator=(rhs);
return *this;
}
@@ -38317,7 +47267,7 @@
return *this;
}
- PhysicalDeviceExternalSemaphoreInfo & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ PhysicalDeviceExternalSemaphoreInfo & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -38346,28 +47296,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo;
-
- public:
- const void* pNext = nullptr;
- ExternalSemaphoreHandleTypeFlagBits handleType;
+ using layout::PhysicalDeviceExternalSemaphoreInfo::sType;
};
static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceExternalSemaphoreInfo>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceFeatures2
+ namespace layout
{
- PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
- : features( features_ )
+ struct PhysicalDeviceFeatures2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() )
+ : features( features_ )
+ {}
+
+ PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this) = rhs;
+ }
+
+ PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2;
+ void* pNext = nullptr;
+ vk::PhysicalDeviceFeatures features;
+ };
+ static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceFeatures2 : public layout::PhysicalDeviceFeatures2
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() )
+ : layout::PhysicalDeviceFeatures2( features_ )
{}
PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
- }
+ : layout::PhysicalDeviceFeatures2( rhs )
+ {}
PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
+ layout::PhysicalDeviceFeatures2::operator=(rhs);
return *this;
}
@@ -38377,7 +47351,7 @@
return *this;
}
- PhysicalDeviceFeatures2 & setFeatures( PhysicalDeviceFeatures features_ )
+ PhysicalDeviceFeatures2 & setFeatures( vk::PhysicalDeviceFeatures features_ )
{
features = features_;
return *this;
@@ -38406,86 +47380,70 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceFeatures2;
-
- public:
- void* pNext = nullptr;
- PhysicalDeviceFeatures features;
+ using layout::PhysicalDeviceFeatures2::sType;
};
static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFeatures2>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceFloat16Int8FeaturesKHR
+ namespace layout
{
- PhysicalDeviceFloat16Int8FeaturesKHR( Bool32 shaderFloat16_ = 0,
- Bool32 shaderInt8_ = 0 )
- : shaderFloat16( shaderFloat16_ )
- , shaderInt8( shaderInt8_ )
+ struct PhysicalDeviceFloatControlsPropertiesKHR
+ {
+ protected:
+ PhysicalDeviceFloatControlsPropertiesKHR()
+ {}
+
+ PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR;
+ void* pNext = nullptr;
+ vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence;
+ vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence;
+ vk::Bool32 shaderSignedZeroInfNanPreserveFloat16;
+ vk::Bool32 shaderSignedZeroInfNanPreserveFloat32;
+ vk::Bool32 shaderSignedZeroInfNanPreserveFloat64;
+ vk::Bool32 shaderDenormPreserveFloat16;
+ vk::Bool32 shaderDenormPreserveFloat32;
+ vk::Bool32 shaderDenormPreserveFloat64;
+ vk::Bool32 shaderDenormFlushToZeroFloat16;
+ vk::Bool32 shaderDenormFlushToZeroFloat32;
+ vk::Bool32 shaderDenormFlushToZeroFloat64;
+ vk::Bool32 shaderRoundingModeRTEFloat16;
+ vk::Bool32 shaderRoundingModeRTEFloat32;
+ vk::Bool32 shaderRoundingModeRTEFloat64;
+ vk::Bool32 shaderRoundingModeRTZFloat16;
+ vk::Bool32 shaderRoundingModeRTZFloat32;
+ vk::Bool32 shaderRoundingModeRTZFloat64;
+ };
+ static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceFloatControlsPropertiesKHR : public layout::PhysicalDeviceFloatControlsPropertiesKHR
+ {
+ PhysicalDeviceFloatControlsPropertiesKHR()
+ : layout::PhysicalDeviceFloatControlsPropertiesKHR()
{}
- PhysicalDeviceFloat16Int8FeaturesKHR( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) );
- }
+ PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs )
+ : layout::PhysicalDeviceFloatControlsPropertiesKHR( rhs )
+ {}
- PhysicalDeviceFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceFloat16Int8FeaturesKHR const & rhs )
+ PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) );
+ layout::PhysicalDeviceFloatControlsPropertiesKHR::operator=(rhs);
return *this;
}
- PhysicalDeviceFloat16Int8FeaturesKHR & setPNext( void* pNext_ )
- {
- pNext = pNext_;
- return *this;
- }
-
- PhysicalDeviceFloat16Int8FeaturesKHR & setShaderFloat16( Bool32 shaderFloat16_ )
- {
- shaderFloat16 = shaderFloat16_;
- return *this;
- }
-
- PhysicalDeviceFloat16Int8FeaturesKHR & setShaderInt8( Bool32 shaderInt8_ )
- {
- shaderInt8 = shaderInt8_;
- return *this;
- }
-
- operator VkPhysicalDeviceFloat16Int8FeaturesKHR const&() const
- {
- return *reinterpret_cast<const VkPhysicalDeviceFloat16Int8FeaturesKHR*>( this );
- }
-
- operator VkPhysicalDeviceFloat16Int8FeaturesKHR &()
- {
- return *reinterpret_cast<VkPhysicalDeviceFloat16Int8FeaturesKHR*>( this );
- }
-
- bool operator==( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const
- {
- return ( sType == rhs.sType )
- && ( pNext == rhs.pNext )
- && ( shaderFloat16 == rhs.shaderFloat16 )
- && ( shaderInt8 == rhs.shaderInt8 );
- }
-
- bool operator!=( PhysicalDeviceFloat16Int8FeaturesKHR const& rhs ) const
- {
- return !operator==( rhs );
- }
-
- private:
- StructureType sType = StructureType::ePhysicalDeviceFloat16Int8FeaturesKHR;
-
- public:
- void* pNext = nullptr;
- Bool32 shaderFloat16;
- Bool32 shaderInt8;
- };
- static_assert( sizeof( PhysicalDeviceFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" );
-
- struct PhysicalDeviceFloatControlsPropertiesKHR
- {
operator VkPhysicalDeviceFloatControlsPropertiesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceFloatControlsPropertiesKHR*>( this );
@@ -38500,8 +47458,8 @@
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( separateDenormSettings == rhs.separateDenormSettings )
- && ( separateRoundingModeSettings == rhs.separateRoundingModeSettings )
+ && ( denormBehaviorIndependence == rhs.denormBehaviorIndependence )
+ && ( roundingModeIndependence == rhs.roundingModeIndependence )
&& ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 )
&& ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 )
&& ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 )
@@ -38525,32 +47483,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR;
-
- public:
- void* pNext = nullptr;
- Bool32 separateDenormSettings;
- Bool32 separateRoundingModeSettings;
- Bool32 shaderSignedZeroInfNanPreserveFloat16;
- Bool32 shaderSignedZeroInfNanPreserveFloat32;
- Bool32 shaderSignedZeroInfNanPreserveFloat64;
- Bool32 shaderDenormPreserveFloat16;
- Bool32 shaderDenormPreserveFloat32;
- Bool32 shaderDenormPreserveFloat64;
- Bool32 shaderDenormFlushToZeroFloat16;
- Bool32 shaderDenormFlushToZeroFloat32;
- Bool32 shaderDenormFlushToZeroFloat64;
- Bool32 shaderRoundingModeRTEFloat16;
- Bool32 shaderRoundingModeRTEFloat32;
- Bool32 shaderRoundingModeRTEFloat64;
- Bool32 shaderRoundingModeRTZFloat16;
- Bool32 shaderRoundingModeRTZFloat32;
- Bool32 shaderRoundingModeRTZFloat64;
+ using layout::PhysicalDeviceFloatControlsPropertiesKHR::sType;
};
static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFloatControlsPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceFragmentDensityMapFeaturesEXT
+ namespace layout
{
+ struct PhysicalDeviceFragmentDensityMapFeaturesEXT
+ {
+ protected:
+ PhysicalDeviceFragmentDensityMapFeaturesEXT()
+ {}
+
+ PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 fragmentDensityMap;
+ vk::Bool32 fragmentDensityMapDynamic;
+ vk::Bool32 fragmentDensityMapNonSubsampledImages;
+ };
+ static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceFragmentDensityMapFeaturesEXT : public layout::PhysicalDeviceFragmentDensityMapFeaturesEXT
+ {
+ PhysicalDeviceFragmentDensityMapFeaturesEXT()
+ : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT()
+ {}
+
+ PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs )
+ : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this );
@@ -38576,18 +47558,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 fragmentDensityMap;
- Bool32 fragmentDensityMapDynamic;
- Bool32 fragmentDensityMapNonSubsampledImages;
+ using layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceFragmentDensityMapPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceFragmentDensityMapPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceFragmentDensityMapPropertiesEXT()
+ {}
+
+ PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
+ void* pNext = nullptr;
+ vk::Extent2D minFragmentDensityTexelSize;
+ vk::Extent2D maxFragmentDensityTexelSize;
+ vk::Bool32 fragmentDensityInvocations;
+ };
+ static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceFragmentDensityMapPropertiesEXT : public layout::PhysicalDeviceFragmentDensityMapPropertiesEXT
+ {
+ PhysicalDeviceFragmentDensityMapPropertiesEXT()
+ : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT()
+ {}
+
+ PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this );
@@ -38613,30 +47633,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- Extent2D minFragmentDensityTexelSize;
- Extent2D maxFragmentDensityTexelSize;
- Bool32 fragmentDensityInvocations;
+ using layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
+ namespace layout
{
- PhysicalDeviceFragmentShaderBarycentricFeaturesNV( Bool32 fragmentShaderBarycentric_ = 0 )
- : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
+ struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 )
+ : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
+ {}
+
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 fragmentShaderBarycentric;
+ };
+ static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV : public layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 )
+ : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( fragmentShaderBarycentric_ )
{}
PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
- }
+ : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( rhs )
+ {}
PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) );
+ layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::operator=(rhs);
return *this;
}
@@ -38646,7 +47688,7 @@
return *this;
}
- PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ )
+ PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric( vk::Bool32 fragmentShaderBarycentric_ )
{
fragmentShaderBarycentric = fragmentShaderBarycentric_;
return *this;
@@ -38675,32 +47717,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 fragmentShaderBarycentric;
+ using layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderBarycentricFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
+ namespace layout
{
- PhysicalDeviceFragmentShaderInterlockFeaturesEXT( Bool32 fragmentShaderSampleInterlock_ = 0,
- Bool32 fragmentShaderPixelInterlock_ = 0,
- Bool32 fragmentShaderShadingRateInterlock_ = 0 )
- : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ )
- , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ )
- , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
+ struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0,
+ vk::Bool32 fragmentShaderPixelInterlock_ = 0,
+ vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 )
+ : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ )
+ , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ )
+ , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ )
+ {}
+
+ PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 fragmentShaderSampleInterlock;
+ vk::Bool32 fragmentShaderPixelInterlock;
+ vk::Bool32 fragmentShaderShadingRateInterlock;
+ };
+ static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT : public layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0,
+ vk::Bool32 fragmentShaderPixelInterlock_ = 0,
+ vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 )
+ : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( fragmentShaderSampleInterlock_, fragmentShaderPixelInterlock_, fragmentShaderShadingRateInterlock_ )
{}
PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( rhs )
+ {}
PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) );
+ layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(rhs);
return *this;
}
@@ -38710,19 +47780,19 @@
return *this;
}
- PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderSampleInterlock( Bool32 fragmentShaderSampleInterlock_ )
+ PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderSampleInterlock( vk::Bool32 fragmentShaderSampleInterlock_ )
{
fragmentShaderSampleInterlock = fragmentShaderSampleInterlock_;
return *this;
}
- PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderPixelInterlock( Bool32 fragmentShaderPixelInterlock_ )
+ PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderPixelInterlock( vk::Bool32 fragmentShaderPixelInterlock_ )
{
fragmentShaderPixelInterlock = fragmentShaderPixelInterlock_;
return *this;
}
- PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderShadingRateInterlock( Bool32 fragmentShaderShadingRateInterlock_ )
+ PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderShadingRateInterlock( vk::Bool32 fragmentShaderShadingRateInterlock_ )
{
fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_;
return *this;
@@ -38753,18 +47823,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 fragmentShaderSampleInterlock;
- Bool32 fragmentShaderPixelInterlock;
- Bool32 fragmentShaderShadingRateInterlock;
+ using layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceGroupProperties
+ namespace layout
{
+ struct PhysicalDeviceGroupProperties
+ {
+ protected:
+ PhysicalDeviceGroupProperties()
+ {}
+
+ PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
+ void* pNext = nullptr;
+ uint32_t physicalDeviceCount;
+ vk::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+ vk::Bool32 subsetAllocation;
+ };
+ static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceGroupProperties : public layout::PhysicalDeviceGroupProperties
+ {
+ PhysicalDeviceGroupProperties()
+ : layout::PhysicalDeviceGroupProperties()
+ {}
+
+ PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs )
+ : layout::PhysicalDeviceGroupProperties( rhs )
+ {}
+
+ PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs )
+ {
+ layout::PhysicalDeviceGroupProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceGroupProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>( this );
@@ -38780,7 +47888,7 @@
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( physicalDeviceCount == rhs.physicalDeviceCount )
- && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 )
+ && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( vk::PhysicalDevice ) ) == 0 )
&& ( subsetAllocation == rhs.subsetAllocation );
}
@@ -38790,30 +47898,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceGroupProperties;
-
- public:
- void* pNext = nullptr;
- uint32_t physicalDeviceCount;
- PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
- Bool32 subsetAllocation;
+ using layout::PhysicalDeviceGroupProperties::sType;
};
static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceGroupProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceHostQueryResetFeaturesEXT
+ namespace layout
{
- PhysicalDeviceHostQueryResetFeaturesEXT( Bool32 hostQueryReset_ = 0 )
- : hostQueryReset( hostQueryReset_ )
+ struct PhysicalDeviceHostQueryResetFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 )
+ : hostQueryReset( hostQueryReset_ )
+ {}
+
+ PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 hostQueryReset;
+ };
+ static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceHostQueryResetFeaturesEXT : public layout::PhysicalDeviceHostQueryResetFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 )
+ : layout::PhysicalDeviceHostQueryResetFeaturesEXT( hostQueryReset_ )
{}
PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceHostQueryResetFeaturesEXT( rhs )
+ {}
PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) );
+ layout::PhysicalDeviceHostQueryResetFeaturesEXT::operator=(rhs);
return *this;
}
@@ -38823,7 +47953,7 @@
return *this;
}
- PhysicalDeviceHostQueryResetFeaturesEXT & setHostQueryReset( Bool32 hostQueryReset_ )
+ PhysicalDeviceHostQueryResetFeaturesEXT & setHostQueryReset( vk::Bool32 hostQueryReset_ )
{
hostQueryReset = hostQueryReset_;
return *this;
@@ -38852,16 +47982,58 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 hostQueryReset;
+ using layout::PhysicalDeviceHostQueryResetFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceHostQueryResetFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceIDProperties
+ namespace layout
{
+ struct PhysicalDeviceIDProperties
+ {
+ protected:
+ PhysicalDeviceIDProperties()
+ {}
+
+ PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceIdProperties;
+ void* pNext = nullptr;
+ uint8_t deviceUUID[VK_UUID_SIZE];
+ uint8_t driverUUID[VK_UUID_SIZE];
+ uint8_t deviceLUID[VK_LUID_SIZE];
+ uint32_t deviceNodeMask;
+ vk::Bool32 deviceLUIDValid;
+ };
+ static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceIDProperties : public layout::PhysicalDeviceIDProperties
+ {
+ PhysicalDeviceIDProperties()
+ : layout::PhysicalDeviceIDProperties()
+ {}
+
+ PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs )
+ : layout::PhysicalDeviceIDProperties( rhs )
+ {}
+
+ PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs )
+ {
+ layout::PhysicalDeviceIDProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceIDProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>( this );
@@ -38889,38 +48061,64 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceIdProperties;
-
- public:
- void* pNext = nullptr;
- uint8_t deviceUUID[VK_UUID_SIZE];
- uint8_t driverUUID[VK_UUID_SIZE];
- uint8_t deviceLUID[VK_LUID_SIZE];
- uint32_t deviceNodeMask;
- Bool32 deviceLUIDValid;
+ using layout::PhysicalDeviceIDProperties::sType;
};
static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceIDProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceImageDrmFormatModifierInfoEXT
+ namespace layout
{
- PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
- SharingMode sharingMode_ = SharingMode::eExclusive,
- uint32_t queueFamilyIndexCount_ = 0,
- const uint32_t* pQueueFamilyIndices_ = nullptr )
- : drmFormatModifier( drmFormatModifier_ )
- , sharingMode( sharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ struct PhysicalDeviceImageDrmFormatModifierInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
+ vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr )
+ : drmFormatModifier( drmFormatModifier_ )
+ , sharingMode( sharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ {}
+
+ PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
+ const void* pNext = nullptr;
+ uint64_t drmFormatModifier;
+ vk::SharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ };
+ static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceImageDrmFormatModifierInfoEXT : public layout::PhysicalDeviceImageDrmFormatModifierInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0,
+ vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr )
+ : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( drmFormatModifier_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ )
{}
PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
- }
+ : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( rhs )
+ {}
PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
+ layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(rhs);
return *this;
}
@@ -38936,7 +48134,7 @@
return *this;
}
- PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( SharingMode sharingMode_ )
+ PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( vk::SharingMode sharingMode_ )
{
sharingMode = sharingMode_;
return *this;
@@ -38980,39 +48178,68 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint64_t drmFormatModifier;
- SharingMode sharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
+ using layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::sType;
};
static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceImageDrmFormatModifierInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceImageFormatInfo2
+ namespace layout
{
- PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined,
- ImageType type_ = ImageType::e1D,
- ImageTiling tiling_ = ImageTiling::eOptimal,
- ImageUsageFlags usage_ = ImageUsageFlags(),
- ImageCreateFlags flags_ = ImageCreateFlags() )
- : format( format_ )
- , type( type_ )
- , tiling( tiling_ )
- , usage( usage_ )
- , flags( flags_ )
+ struct PhysicalDeviceImageFormatInfo2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+ vk::ImageType type_ = vk::ImageType::e1D,
+ vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() )
+ : format( format_ )
+ , type( type_ )
+ , tiling( tiling_ )
+ , usage( usage_ )
+ , flags( flags_ )
+ {}
+
+ PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
+ }
+
+ PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
+ const void* pNext = nullptr;
+ vk::Format format;
+ vk::ImageType type;
+ vk::ImageTiling tiling;
+ vk::ImageUsageFlags usage;
+ vk::ImageCreateFlags flags;
+ };
+ static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceImageFormatInfo2 : public layout::PhysicalDeviceImageFormatInfo2
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+ vk::ImageType type_ = vk::ImageType::e1D,
+ vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal,
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() )
+ : layout::PhysicalDeviceImageFormatInfo2( format_, type_, tiling_, usage_, flags_ )
{}
PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
- }
+ : layout::PhysicalDeviceImageFormatInfo2( rhs )
+ {}
PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
+ layout::PhysicalDeviceImageFormatInfo2::operator=(rhs);
return *this;
}
@@ -39022,31 +48249,31 @@
return *this;
}
- PhysicalDeviceImageFormatInfo2 & setFormat( Format format_ )
+ PhysicalDeviceImageFormatInfo2 & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- PhysicalDeviceImageFormatInfo2 & setType( ImageType type_ )
+ PhysicalDeviceImageFormatInfo2 & setType( vk::ImageType type_ )
{
type = type_;
return *this;
}
- PhysicalDeviceImageFormatInfo2 & setTiling( ImageTiling tiling_ )
+ PhysicalDeviceImageFormatInfo2 & setTiling( vk::ImageTiling tiling_ )
{
tiling = tiling_;
return *this;
}
- PhysicalDeviceImageFormatInfo2 & setUsage( ImageUsageFlags usage_ )
+ PhysicalDeviceImageFormatInfo2 & setUsage( vk::ImageUsageFlags usage_ )
{
usage = usage_;
return *this;
}
- PhysicalDeviceImageFormatInfo2 & setFlags( ImageCreateFlags flags_ )
+ PhysicalDeviceImageFormatInfo2 & setFlags( vk::ImageCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -39079,32 +48306,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2;
-
- public:
- const void* pNext = nullptr;
- Format format;
- ImageType type;
- ImageTiling tiling;
- ImageUsageFlags usage;
- ImageCreateFlags flags;
+ using layout::PhysicalDeviceImageFormatInfo2::sType;
};
static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceImageFormatInfo2>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceImageViewImageFormatInfoEXT
+ namespace layout
{
- PhysicalDeviceImageViewImageFormatInfoEXT( ImageViewType imageViewType_ = ImageViewType::e1D )
- : imageViewType( imageViewType_ )
+ struct PhysicalDeviceImageViewImageFormatInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D )
+ : imageViewType( imageViewType_ )
+ {}
+
+ PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
+ void* pNext = nullptr;
+ vk::ImageViewType imageViewType;
+ };
+ static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceImageViewImageFormatInfoEXT : public layout::PhysicalDeviceImageViewImageFormatInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D )
+ : layout::PhysicalDeviceImageViewImageFormatInfoEXT( imageViewType_ )
{}
PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) );
- }
+ : layout::PhysicalDeviceImageViewImageFormatInfoEXT( rhs )
+ {}
PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) );
+ layout::PhysicalDeviceImageViewImageFormatInfoEXT::operator=(rhs);
return *this;
}
@@ -39114,7 +48361,7 @@
return *this;
}
- PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( ImageViewType imageViewType_ )
+ PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( vk::ImageViewType imageViewType_ )
{
imageViewType = imageViewType_;
return *this;
@@ -39143,30 +48390,224 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT;
-
- public:
- void* pNext = nullptr;
- ImageViewType imageViewType;
+ using layout::PhysicalDeviceImageViewImageFormatInfoEXT::sType;
};
static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceImageViewImageFormatInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceInlineUniformBlockFeaturesEXT
+ namespace layout
{
- PhysicalDeviceInlineUniformBlockFeaturesEXT( Bool32 inlineUniformBlock_ = 0,
- Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 )
- : inlineUniformBlock( inlineUniformBlock_ )
- , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+ struct PhysicalDeviceImagelessFramebufferFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 )
+ : imagelessFramebuffer( imagelessFramebuffer_ )
+ {}
+
+ PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 imagelessFramebuffer;
+ };
+ static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceImagelessFramebufferFeaturesKHR : public layout::PhysicalDeviceImagelessFramebufferFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 )
+ : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( imagelessFramebuffer_ )
+ {}
+
+ PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
+ : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( rhs )
+ {}
+
+ PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs )
+ {
+ layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceImagelessFramebufferFeaturesKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceImagelessFramebufferFeaturesKHR & setImagelessFramebuffer( vk::Bool32 imagelessFramebuffer_ )
+ {
+ imagelessFramebuffer = imagelessFramebuffer_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceImagelessFramebufferFeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDeviceImagelessFramebufferFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDeviceImagelessFramebufferFeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( imagelessFramebuffer == rhs.imagelessFramebuffer );
+ }
+
+ bool operator!=( PhysicalDeviceImagelessFramebufferFeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceImagelessFramebufferFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceIndexTypeUint8FeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 )
+ : indexTypeUint8( indexTypeUint8_ )
+ {}
+
+ PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 indexTypeUint8;
+ };
+ static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceIndexTypeUint8FeaturesEXT : public layout::PhysicalDeviceIndexTypeUint8FeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 )
+ : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( indexTypeUint8_ )
+ {}
+
+ PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+ : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceIndexTypeUint8FeaturesEXT & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceIndexTypeUint8FeaturesEXT & setIndexTypeUint8( vk::Bool32 indexTypeUint8_ )
+ {
+ indexTypeUint8 = indexTypeUint8_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( indexTypeUint8 == rhs.indexTypeUint8 );
+ }
+
+ bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceIndexTypeUint8FeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceInlineUniformBlockFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0,
+ vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 )
+ : inlineUniformBlock( inlineUniformBlock_ )
+ , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+ {}
+
+ PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 inlineUniformBlock;
+ vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+ };
+ static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceInlineUniformBlockFeaturesEXT : public layout::PhysicalDeviceInlineUniformBlockFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0,
+ vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 )
+ : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( inlineUniformBlock_, descriptorBindingInlineUniformBlockUpdateAfterBind_ )
{}
PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( rhs )
+ {}
PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) );
+ layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::operator=(rhs);
return *this;
}
@@ -39176,13 +48617,13 @@
return *this;
}
- PhysicalDeviceInlineUniformBlockFeaturesEXT & setInlineUniformBlock( Bool32 inlineUniformBlock_ )
+ PhysicalDeviceInlineUniformBlockFeaturesEXT & setInlineUniformBlock( vk::Bool32 inlineUniformBlock_ )
{
inlineUniformBlock = inlineUniformBlock_;
return *this;
}
- PhysicalDeviceInlineUniformBlockFeaturesEXT & setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ )
+ PhysicalDeviceInlineUniformBlockFeaturesEXT & setDescriptorBindingInlineUniformBlockUpdateAfterBind( vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ )
{
descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_;
return *this;
@@ -39212,17 +48653,58 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 inlineUniformBlock;
- Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+ using layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceInlineUniformBlockPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceInlineUniformBlockPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceInlineUniformBlockPropertiesEXT()
+ {}
+
+ PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t maxInlineUniformBlockSize;
+ uint32_t maxPerStageDescriptorInlineUniformBlocks;
+ uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+ uint32_t maxDescriptorSetInlineUniformBlocks;
+ uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+ };
+ static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceInlineUniformBlockPropertiesEXT : public layout::PhysicalDeviceInlineUniformBlockPropertiesEXT
+ {
+ PhysicalDeviceInlineUniformBlockPropertiesEXT()
+ : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT()
+ {}
+
+ PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this );
@@ -39250,20 +48732,27 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t maxInlineUniformBlockSize;
- uint32_t maxPerStageDescriptorInlineUniformBlocks;
- uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
- uint32_t maxDescriptorSetInlineUniformBlocks;
- uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+ using layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
struct PhysicalDeviceLimits
{
+ PhysicalDeviceLimits()
+ {}
+
+ PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceLimits*>(this) = rhs;
+ }
+
+ PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceLimits*>(this) = rhs;
+ return *this;
+ }
+
operator VkPhysicalDeviceLimits const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceLimits*>( this );
@@ -39389,6 +48878,7 @@
return !operator==( rhs );
}
+ public:
uint32_t maxImageDimension1D;
uint32_t maxImageDimension2D;
uint32_t maxImageDimension3D;
@@ -39400,8 +48890,8 @@
uint32_t maxPushConstantsSize;
uint32_t maxMemoryAllocationCount;
uint32_t maxSamplerAllocationCount;
- DeviceSize bufferImageGranularity;
- DeviceSize sparseAddressSpaceSize;
+ vk::DeviceSize bufferImageGranularity;
+ vk::DeviceSize sparseAddressSpaceSize;
uint32_t maxBoundDescriptorSets;
uint32_t maxPerStageDescriptorSamplers;
uint32_t maxPerStageDescriptorUniformBuffers;
@@ -39456,9 +48946,9 @@
float viewportBoundsRange[2];
uint32_t viewportSubPixelBits;
size_t minMemoryMapAlignment;
- DeviceSize minTexelBufferOffsetAlignment;
- DeviceSize minUniformBufferOffsetAlignment;
- DeviceSize minStorageBufferOffsetAlignment;
+ vk::DeviceSize minTexelBufferOffsetAlignment;
+ vk::DeviceSize minUniformBufferOffsetAlignment;
+ vk::DeviceSize minStorageBufferOffsetAlignment;
int32_t minTexelOffset;
uint32_t maxTexelOffset;
int32_t minTexelGatherOffset;
@@ -39469,18 +48959,18 @@
uint32_t maxFramebufferWidth;
uint32_t maxFramebufferHeight;
uint32_t maxFramebufferLayers;
- SampleCountFlags framebufferColorSampleCounts;
- SampleCountFlags framebufferDepthSampleCounts;
- SampleCountFlags framebufferStencilSampleCounts;
- SampleCountFlags framebufferNoAttachmentsSampleCounts;
+ vk::SampleCountFlags framebufferColorSampleCounts;
+ vk::SampleCountFlags framebufferDepthSampleCounts;
+ vk::SampleCountFlags framebufferStencilSampleCounts;
+ vk::SampleCountFlags framebufferNoAttachmentsSampleCounts;
uint32_t maxColorAttachments;
- SampleCountFlags sampledImageColorSampleCounts;
- SampleCountFlags sampledImageIntegerSampleCounts;
- SampleCountFlags sampledImageDepthSampleCounts;
- SampleCountFlags sampledImageStencilSampleCounts;
- SampleCountFlags storageImageSampleCounts;
+ vk::SampleCountFlags sampledImageColorSampleCounts;
+ vk::SampleCountFlags sampledImageIntegerSampleCounts;
+ vk::SampleCountFlags sampledImageDepthSampleCounts;
+ vk::SampleCountFlags sampledImageStencilSampleCounts;
+ vk::SampleCountFlags storageImageSampleCounts;
uint32_t maxSampleMaskWords;
- Bool32 timestampComputeAndGraphics;
+ vk::Bool32 timestampComputeAndGraphics;
float timestampPeriod;
uint32_t maxClipDistances;
uint32_t maxCullDistances;
@@ -39490,16 +48980,269 @@
float lineWidthRange[2];
float pointSizeGranularity;
float lineWidthGranularity;
- Bool32 strictLines;
- Bool32 standardSampleLocations;
- DeviceSize optimalBufferCopyOffsetAlignment;
- DeviceSize optimalBufferCopyRowPitchAlignment;
- DeviceSize nonCoherentAtomSize;
+ vk::Bool32 strictLines;
+ vk::Bool32 standardSampleLocations;
+ vk::DeviceSize optimalBufferCopyOffsetAlignment;
+ vk::DeviceSize optimalBufferCopyRowPitchAlignment;
+ vk::DeviceSize nonCoherentAtomSize;
};
static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceLimits>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMaintenance3Properties
+ namespace layout
{
+ struct PhysicalDeviceLineRasterizationFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0,
+ vk::Bool32 bresenhamLines_ = 0,
+ vk::Bool32 smoothLines_ = 0,
+ vk::Bool32 stippledRectangularLines_ = 0,
+ vk::Bool32 stippledBresenhamLines_ = 0,
+ vk::Bool32 stippledSmoothLines_ = 0 )
+ : rectangularLines( rectangularLines_ )
+ , bresenhamLines( bresenhamLines_ )
+ , smoothLines( smoothLines_ )
+ , stippledRectangularLines( stippledRectangularLines_ )
+ , stippledBresenhamLines( stippledBresenhamLines_ )
+ , stippledSmoothLines( stippledSmoothLines_ )
+ {}
+
+ PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 rectangularLines;
+ vk::Bool32 bresenhamLines;
+ vk::Bool32 smoothLines;
+ vk::Bool32 stippledRectangularLines;
+ vk::Bool32 stippledBresenhamLines;
+ vk::Bool32 stippledSmoothLines;
+ };
+ static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceLineRasterizationFeaturesEXT : public layout::PhysicalDeviceLineRasterizationFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0,
+ vk::Bool32 bresenhamLines_ = 0,
+ vk::Bool32 smoothLines_ = 0,
+ vk::Bool32 stippledRectangularLines_ = 0,
+ vk::Bool32 stippledBresenhamLines_ = 0,
+ vk::Bool32 stippledSmoothLines_ = 0 )
+ : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rectangularLines_, bresenhamLines_, smoothLines_, stippledRectangularLines_, stippledBresenhamLines_, stippledSmoothLines_ )
+ {}
+
+ PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+ : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceLineRasterizationFeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setRectangularLines( vk::Bool32 rectangularLines_ )
+ {
+ rectangularLines = rectangularLines_;
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setBresenhamLines( vk::Bool32 bresenhamLines_ )
+ {
+ bresenhamLines = bresenhamLines_;
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setSmoothLines( vk::Bool32 smoothLines_ )
+ {
+ smoothLines = smoothLines_;
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setStippledRectangularLines( vk::Bool32 stippledRectangularLines_ )
+ {
+ stippledRectangularLines = stippledRectangularLines_;
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setStippledBresenhamLines( vk::Bool32 stippledBresenhamLines_ )
+ {
+ stippledBresenhamLines = stippledBresenhamLines_;
+ return *this;
+ }
+
+ PhysicalDeviceLineRasterizationFeaturesEXT & setStippledSmoothLines( vk::Bool32 stippledSmoothLines_ )
+ {
+ stippledSmoothLines = stippledSmoothLines_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceLineRasterizationFeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceLineRasterizationFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( rectangularLines == rhs.rectangularLines )
+ && ( bresenhamLines == rhs.bresenhamLines )
+ && ( smoothLines == rhs.smoothLines )
+ && ( stippledRectangularLines == rhs.stippledRectangularLines )
+ && ( stippledBresenhamLines == rhs.stippledBresenhamLines )
+ && ( stippledSmoothLines == rhs.stippledSmoothLines );
+ }
+
+ bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceLineRasterizationFeaturesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceLineRasterizationPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceLineRasterizationPropertiesEXT()
+ {}
+
+ PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t lineSubPixelPrecisionBits;
+ };
+ static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceLineRasterizationPropertiesEXT : public layout::PhysicalDeviceLineRasterizationPropertiesEXT
+ {
+ PhysicalDeviceLineRasterizationPropertiesEXT()
+ : layout::PhysicalDeviceLineRasterizationPropertiesEXT()
+ {}
+
+ PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceLineRasterizationPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceLineRasterizationPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPhysicalDeviceLineRasterizationPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceLineRasterizationPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits );
+ }
+
+ bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceLineRasterizationPropertiesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceMaintenance3Properties
+ {
+ protected:
+ PhysicalDeviceMaintenance3Properties()
+ {}
+
+ PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this) = rhs;
+ }
+
+ PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
+ void* pNext = nullptr;
+ uint32_t maxPerSetDescriptors;
+ vk::DeviceSize maxMemoryAllocationSize;
+ };
+ static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMaintenance3Properties : public layout::PhysicalDeviceMaintenance3Properties
+ {
+ PhysicalDeviceMaintenance3Properties()
+ : layout::PhysicalDeviceMaintenance3Properties()
+ {}
+
+ PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs )
+ : layout::PhysicalDeviceMaintenance3Properties( rhs )
+ {}
+
+ PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs )
+ {
+ layout::PhysicalDeviceMaintenance3Properties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceMaintenance3Properties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>( this );
@@ -39524,17 +49267,55 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties;
-
- public:
- void* pNext = nullptr;
- uint32_t maxPerSetDescriptors;
- DeviceSize maxMemoryAllocationSize;
+ using layout::PhysicalDeviceMaintenance3Properties::sType;
};
static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMaintenance3Properties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMemoryBudgetPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceMemoryBudgetPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceMemoryBudgetPropertiesEXT()
+ {}
+
+ PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
+ void* pNext = nullptr;
+ vk::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
+ vk::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+ };
+ static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMemoryBudgetPropertiesEXT : public layout::PhysicalDeviceMemoryBudgetPropertiesEXT
+ {
+ PhysicalDeviceMemoryBudgetPropertiesEXT()
+ : layout::PhysicalDeviceMemoryBudgetPropertiesEXT()
+ {}
+
+ PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceMemoryBudgetPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceMemoryBudgetPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>( this );
@@ -39549,8 +49330,8 @@
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
- && ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 )
- && ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( DeviceSize ) ) == 0 );
+ && ( memcmp( heapBudget, rhs.heapBudget, VK_MAX_MEMORY_HEAPS * sizeof( vk::DeviceSize ) ) == 0 )
+ && ( memcmp( heapUsage, rhs.heapUsage, VK_MAX_MEMORY_HEAPS * sizeof( vk::DeviceSize ) ) == 0 );
}
bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const& rhs ) const
@@ -39559,29 +49340,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
- DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+ using layout::PhysicalDeviceMemoryBudgetPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMemoryBudgetPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMemoryPriorityFeaturesEXT
+ namespace layout
{
- PhysicalDeviceMemoryPriorityFeaturesEXT( Bool32 memoryPriority_ = 0 )
- : memoryPriority( memoryPriority_ )
+ struct PhysicalDeviceMemoryPriorityFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 )
+ : memoryPriority( memoryPriority_ )
+ {}
+
+ PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 memoryPriority;
+ };
+ static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMemoryPriorityFeaturesEXT : public layout::PhysicalDeviceMemoryPriorityFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 )
+ : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( memoryPriority_ )
{}
PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( rhs )
+ {}
PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) );
+ layout::PhysicalDeviceMemoryPriorityFeaturesEXT::operator=(rhs);
return *this;
}
@@ -39591,7 +49395,7 @@
return *this;
}
- PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( Bool32 memoryPriority_ )
+ PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( vk::Bool32 memoryPriority_ )
{
memoryPriority = memoryPriority_;
return *this;
@@ -39620,16 +49424,27 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 memoryPriority;
+ using layout::PhysicalDeviceMemoryPriorityFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMemoryPriorityFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
struct PhysicalDeviceMemoryProperties
{
+ PhysicalDeviceMemoryProperties()
+ {}
+
+ PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkPhysicalDeviceMemoryProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>( this );
@@ -39643,9 +49458,9 @@
bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
{
return ( memoryTypeCount == rhs.memoryTypeCount )
- && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
+ && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( vk::MemoryType ) ) == 0 )
&& ( memoryHeapCount == rhs.memoryHeapCount )
- && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
+ && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( vk::MemoryHeap ) ) == 0 );
}
bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
@@ -39653,15 +49468,58 @@
return !operator==( rhs );
}
+ public:
uint32_t memoryTypeCount;
- MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ vk::MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
uint32_t memoryHeapCount;
- MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
+ vk::MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
};
static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMemoryProperties2
+ namespace layout
{
+ struct PhysicalDeviceMemoryProperties2
+ {
+ protected:
+ PhysicalDeviceMemoryProperties2()
+ {}
+
+ PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this) = rhs;
+ }
+
+ PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
+ void* pNext = nullptr;
+ vk::PhysicalDeviceMemoryProperties memoryProperties;
+ };
+ static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMemoryProperties2 : public layout::PhysicalDeviceMemoryProperties2
+ {
+ PhysicalDeviceMemoryProperties2()
+ : layout::PhysicalDeviceMemoryProperties2()
+ {}
+
+ PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs )
+ : layout::PhysicalDeviceMemoryProperties2( rhs )
+ {}
+
+ PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs )
+ {
+ layout::PhysicalDeviceMemoryProperties2::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceMemoryProperties2 const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>( this );
@@ -39685,30 +49543,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2;
-
- public:
- void* pNext = nullptr;
- PhysicalDeviceMemoryProperties memoryProperties;
+ using layout::PhysicalDeviceMemoryProperties2::sType;
};
static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties2>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMeshShaderFeaturesNV
+ namespace layout
{
- PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = 0,
- Bool32 meshShader_ = 0 )
- : taskShader( taskShader_ )
- , meshShader( meshShader_ )
+ struct PhysicalDeviceMeshShaderFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0,
+ vk::Bool32 meshShader_ = 0 )
+ : taskShader( taskShader_ )
+ , meshShader( meshShader_ )
+ {}
+
+ PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 taskShader;
+ vk::Bool32 meshShader;
+ };
+ static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMeshShaderFeaturesNV : public layout::PhysicalDeviceMeshShaderFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0,
+ vk::Bool32 meshShader_ = 0 )
+ : layout::PhysicalDeviceMeshShaderFeaturesNV( taskShader_, meshShader_ )
{}
PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
- }
+ : layout::PhysicalDeviceMeshShaderFeaturesNV( rhs )
+ {}
PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
+ layout::PhysicalDeviceMeshShaderFeaturesNV::operator=(rhs);
return *this;
}
@@ -39718,13 +49602,13 @@
return *this;
}
- PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( Bool32 taskShader_ )
+ PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( vk::Bool32 taskShader_ )
{
taskShader = taskShader_;
return *this;
}
- PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( Bool32 meshShader_ )
+ PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( vk::Bool32 meshShader_ )
{
meshShader = meshShader_;
return *this;
@@ -39754,17 +49638,66 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 taskShader;
- Bool32 meshShader;
+ using layout::PhysicalDeviceMeshShaderFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMeshShaderPropertiesNV
+ namespace layout
{
+ struct PhysicalDeviceMeshShaderPropertiesNV
+ {
+ protected:
+ PhysicalDeviceMeshShaderPropertiesNV()
+ {}
+
+ PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
+ void* pNext = nullptr;
+ uint32_t maxDrawMeshTasksCount;
+ uint32_t maxTaskWorkGroupInvocations;
+ uint32_t maxTaskWorkGroupSize[3];
+ uint32_t maxTaskTotalMemorySize;
+ uint32_t maxTaskOutputCount;
+ uint32_t maxMeshWorkGroupInvocations;
+ uint32_t maxMeshWorkGroupSize[3];
+ uint32_t maxMeshTotalMemorySize;
+ uint32_t maxMeshOutputVertices;
+ uint32_t maxMeshOutputPrimitives;
+ uint32_t maxMeshMultiviewViewCount;
+ uint32_t meshOutputPerVertexGranularity;
+ uint32_t meshOutputPerPrimitiveGranularity;
+ };
+ static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMeshShaderPropertiesNV : public layout::PhysicalDeviceMeshShaderPropertiesNV
+ {
+ PhysicalDeviceMeshShaderPropertiesNV()
+ : layout::PhysicalDeviceMeshShaderPropertiesNV()
+ {}
+
+ PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+ : layout::PhysicalDeviceMeshShaderPropertiesNV( rhs )
+ {}
+
+ PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs )
+ {
+ layout::PhysicalDeviceMeshShaderPropertiesNV::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>( this );
@@ -39800,44 +49733,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV;
-
- public:
- void* pNext = nullptr;
- uint32_t maxDrawMeshTasksCount;
- uint32_t maxTaskWorkGroupInvocations;
- uint32_t maxTaskWorkGroupSize[3];
- uint32_t maxTaskTotalMemorySize;
- uint32_t maxTaskOutputCount;
- uint32_t maxMeshWorkGroupInvocations;
- uint32_t maxMeshWorkGroupSize[3];
- uint32_t maxMeshTotalMemorySize;
- uint32_t maxMeshOutputVertices;
- uint32_t maxMeshOutputPrimitives;
- uint32_t maxMeshMultiviewViewCount;
- uint32_t meshOutputPerVertexGranularity;
- uint32_t meshOutputPerPrimitiveGranularity;
+ using layout::PhysicalDeviceMeshShaderPropertiesNV::sType;
};
static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMultiviewFeatures
+ namespace layout
{
- PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = 0,
- Bool32 multiviewGeometryShader_ = 0,
- Bool32 multiviewTessellationShader_ = 0 )
- : multiview( multiview_ )
- , multiviewGeometryShader( multiviewGeometryShader_ )
- , multiviewTessellationShader( multiviewTessellationShader_ )
+ struct PhysicalDeviceMultiviewFeatures
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0,
+ vk::Bool32 multiviewGeometryShader_ = 0,
+ vk::Bool32 multiviewTessellationShader_ = 0 )
+ : multiview( multiview_ )
+ , multiviewGeometryShader( multiviewGeometryShader_ )
+ , multiviewTessellationShader( multiviewTessellationShader_ )
+ {}
+
+ PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
+ }
+
+ PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
+ void* pNext = nullptr;
+ vk::Bool32 multiview;
+ vk::Bool32 multiviewGeometryShader;
+ vk::Bool32 multiviewTessellationShader;
+ };
+ static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMultiviewFeatures : public layout::PhysicalDeviceMultiviewFeatures
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0,
+ vk::Bool32 multiviewGeometryShader_ = 0,
+ vk::Bool32 multiviewTessellationShader_ = 0 )
+ : layout::PhysicalDeviceMultiviewFeatures( multiview_, multiviewGeometryShader_, multiviewTessellationShader_ )
{}
PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
- }
+ : layout::PhysicalDeviceMultiviewFeatures( rhs )
+ {}
PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
+ layout::PhysicalDeviceMultiviewFeatures::operator=(rhs);
return *this;
}
@@ -39847,19 +49796,19 @@
return *this;
}
- PhysicalDeviceMultiviewFeatures & setMultiview( Bool32 multiview_ )
+ PhysicalDeviceMultiviewFeatures & setMultiview( vk::Bool32 multiview_ )
{
multiview = multiview_;
return *this;
}
- PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ )
+ PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( vk::Bool32 multiviewGeometryShader_ )
{
multiviewGeometryShader = multiviewGeometryShader_;
return *this;
}
- PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ )
+ PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( vk::Bool32 multiviewTessellationShader_ )
{
multiviewTessellationShader = multiviewTessellationShader_;
return *this;
@@ -39890,18 +49839,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures;
-
- public:
- void* pNext = nullptr;
- Bool32 multiview;
- Bool32 multiviewGeometryShader;
- Bool32 multiviewTessellationShader;
+ using layout::PhysicalDeviceMultiviewFeatures::sType;
};
static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMultiviewFeatures>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+ namespace layout
{
+ struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+ {
+ protected:
+ PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+ {}
+
+ PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this) = rhs;
+ }
+
+ PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+ void* pNext = nullptr;
+ vk::Bool32 perViewPositionAllComponents;
+ };
+ static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : public layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
+ {
+ PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+ : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+ {}
+
+ PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
+ : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( rhs )
+ {}
+
+ PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs )
+ {
+ layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this );
@@ -39925,16 +49910,55 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-
- public:
- void* pNext = nullptr;
- Bool32 perViewPositionAllComponents;
+ using layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::sType;
};
static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceMultiviewProperties
+ namespace layout
{
+ struct PhysicalDeviceMultiviewProperties
+ {
+ protected:
+ PhysicalDeviceMultiviewProperties()
+ {}
+
+ PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
+ void* pNext = nullptr;
+ uint32_t maxMultiviewViewCount;
+ uint32_t maxMultiviewInstanceIndex;
+ };
+ static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceMultiviewProperties : public layout::PhysicalDeviceMultiviewProperties
+ {
+ PhysicalDeviceMultiviewProperties()
+ : layout::PhysicalDeviceMultiviewProperties()
+ {}
+
+ PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs )
+ : layout::PhysicalDeviceMultiviewProperties( rhs )
+ {}
+
+ PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs )
+ {
+ layout::PhysicalDeviceMultiviewProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceMultiviewProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>( this );
@@ -39959,17 +49983,57 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties;
-
- public:
- void* pNext = nullptr;
- uint32_t maxMultiviewViewCount;
- uint32_t maxMultiviewInstanceIndex;
+ using layout::PhysicalDeviceMultiviewProperties::sType;
};
static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceMultiviewProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDevicePCIBusInfoPropertiesEXT
+ namespace layout
{
+ struct PhysicalDevicePCIBusInfoPropertiesEXT
+ {
+ protected:
+ PhysicalDevicePCIBusInfoPropertiesEXT()
+ {}
+
+ PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t pciDomain;
+ uint32_t pciBus;
+ uint32_t pciDevice;
+ uint32_t pciFunction;
+ };
+ static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDevicePCIBusInfoPropertiesEXT : public layout::PhysicalDevicePCIBusInfoPropertiesEXT
+ {
+ PhysicalDevicePCIBusInfoPropertiesEXT()
+ : layout::PhysicalDevicePCIBusInfoPropertiesEXT()
+ {}
+
+ PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs )
+ : layout::PhysicalDevicePCIBusInfoPropertiesEXT( rhs )
+ {}
+
+ PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDevicePCIBusInfoPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this );
@@ -39996,19 +50060,138 @@
}
private:
- StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t pciDomain;
- uint32_t pciBus;
- uint32_t pciDevice;
- uint32_t pciFunction;
+ using layout::PhysicalDevicePCIBusInfoPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDevicePCIBusInfoPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDevicePointClippingProperties
+ namespace layout
{
+ struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 )
+ : pipelineExecutableInfo( pipelineExecutableInfo_ )
+ {}
+
+ PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 pipelineExecutableInfo;
+ };
+ static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 )
+ : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( pipelineExecutableInfo_ )
+ {}
+
+ PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+ : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( rhs )
+ {}
+
+ PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs )
+ {
+ layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPipelineExecutableInfo( vk::Bool32 pipelineExecutableInfo_ )
+ {
+ pipelineExecutableInfo = pipelineExecutableInfo_;
+ return *this;
+ }
+
+ operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( pipelineExecutableInfo == rhs.pipelineExecutableInfo );
+ }
+
+ bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDevicePointClippingProperties
+ {
+ protected:
+ PhysicalDevicePointClippingProperties()
+ {}
+
+ PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this) = rhs;
+ }
+
+ PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
+ void* pNext = nullptr;
+ vk::PointClippingBehavior pointClippingBehavior;
+ };
+ static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDevicePointClippingProperties : public layout::PhysicalDevicePointClippingProperties
+ {
+ PhysicalDevicePointClippingProperties()
+ : layout::PhysicalDevicePointClippingProperties()
+ {}
+
+ PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs )
+ : layout::PhysicalDevicePointClippingProperties( rhs )
+ {}
+
+ PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs )
+ {
+ layout::PhysicalDevicePointClippingProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDevicePointClippingProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>( this );
@@ -40032,16 +50215,27 @@
}
private:
- StructureType sType = StructureType::ePhysicalDevicePointClippingProperties;
-
- public:
- void* pNext = nullptr;
- PointClippingBehavior pointClippingBehavior;
+ using layout::PhysicalDevicePointClippingProperties::sType;
};
static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDevicePointClippingProperties>::value, "struct wrapper is not a standard layout!" );
struct PhysicalDeviceSparseProperties
{
+ PhysicalDeviceSparseProperties()
+ {}
+
+ PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkPhysicalDeviceSparseProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>( this );
@@ -40066,16 +50260,32 @@
return !operator==( rhs );
}
- Bool32 residencyStandard2DBlockShape;
- Bool32 residencyStandard2DMultisampleBlockShape;
- Bool32 residencyStandard3DBlockShape;
- Bool32 residencyAlignedMipSize;
- Bool32 residencyNonResidentStrict;
+ public:
+ vk::Bool32 residencyStandard2DBlockShape;
+ vk::Bool32 residencyStandard2DMultisampleBlockShape;
+ vk::Bool32 residencyStandard3DBlockShape;
+ vk::Bool32 residencyAlignedMipSize;
+ vk::Bool32 residencyNonResidentStrict;
};
static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSparseProperties>::value, "struct wrapper is not a standard layout!" );
struct PhysicalDeviceProperties
{
+ PhysicalDeviceProperties()
+ {}
+
+ PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkPhysicalDeviceProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceProperties*>( this );
@@ -40104,20 +50314,63 @@
return !operator==( rhs );
}
+ public:
uint32_t apiVersion;
uint32_t driverVersion;
uint32_t vendorID;
uint32_t deviceID;
- PhysicalDeviceType deviceType;
+ vk::PhysicalDeviceType deviceType;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
uint8_t pipelineCacheUUID[VK_UUID_SIZE];
- PhysicalDeviceLimits limits;
- PhysicalDeviceSparseProperties sparseProperties;
+ vk::PhysicalDeviceLimits limits;
+ vk::PhysicalDeviceSparseProperties sparseProperties;
};
static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceProperties2
+ namespace layout
{
+ struct PhysicalDeviceProperties2
+ {
+ protected:
+ PhysicalDeviceProperties2()
+ {}
+
+ PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProperties2*>(this) = rhs;
+ }
+
+ PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProperties2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceProperties2;
+ void* pNext = nullptr;
+ vk::PhysicalDeviceProperties properties;
+ };
+ static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceProperties2 : public layout::PhysicalDeviceProperties2
+ {
+ PhysicalDeviceProperties2()
+ : layout::PhysicalDeviceProperties2()
+ {}
+
+ PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs )
+ : layout::PhysicalDeviceProperties2( rhs )
+ {}
+
+ PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs )
+ {
+ layout::PhysicalDeviceProperties2::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceProperties2 const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceProperties2*>( this );
@@ -40141,28 +50394,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceProperties2;
-
- public:
- void* pNext = nullptr;
- PhysicalDeviceProperties properties;
+ using layout::PhysicalDeviceProperties2::sType;
};
static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceProperties2>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceProtectedMemoryFeatures
+ namespace layout
{
- PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = 0 )
- : protectedMemory( protectedMemory_ )
+ struct PhysicalDeviceProtectedMemoryFeatures
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 )
+ : protectedMemory( protectedMemory_ )
+ {}
+
+ PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
+ }
+
+ PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
+ void* pNext = nullptr;
+ vk::Bool32 protectedMemory;
+ };
+ static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceProtectedMemoryFeatures : public layout::PhysicalDeviceProtectedMemoryFeatures
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 )
+ : layout::PhysicalDeviceProtectedMemoryFeatures( protectedMemory_ )
{}
PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
- }
+ : layout::PhysicalDeviceProtectedMemoryFeatures( rhs )
+ {}
PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
+ layout::PhysicalDeviceProtectedMemoryFeatures::operator=(rhs);
return *this;
}
@@ -40172,7 +50449,7 @@
return *this;
}
- PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( Bool32 protectedMemory_ )
+ PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( vk::Bool32 protectedMemory_ )
{
protectedMemory = protectedMemory_;
return *this;
@@ -40201,16 +50478,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures;
-
- public:
- void* pNext = nullptr;
- Bool32 protectedMemory;
+ using layout::PhysicalDeviceProtectedMemoryFeatures::sType;
};
static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryFeatures>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceProtectedMemoryProperties
+ namespace layout
{
+ struct PhysicalDeviceProtectedMemoryProperties
+ {
+ protected:
+ PhysicalDeviceProtectedMemoryProperties()
+ {}
+
+ PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
+ void* pNext = nullptr;
+ vk::Bool32 protectedNoFault;
+ };
+ static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceProtectedMemoryProperties : public layout::PhysicalDeviceProtectedMemoryProperties
+ {
+ PhysicalDeviceProtectedMemoryProperties()
+ : layout::PhysicalDeviceProtectedMemoryProperties()
+ {}
+
+ PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
+ : layout::PhysicalDeviceProtectedMemoryProperties( rhs )
+ {}
+
+ PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs )
+ {
+ layout::PhysicalDeviceProtectedMemoryProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceProtectedMemoryProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>( this );
@@ -40234,16 +50549,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties;
-
- public:
- void* pNext = nullptr;
- Bool32 protectedNoFault;
+ using layout::PhysicalDeviceProtectedMemoryProperties::sType;
};
static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDevicePushDescriptorPropertiesKHR
+ namespace layout
{
+ struct PhysicalDevicePushDescriptorPropertiesKHR
+ {
+ protected:
+ PhysicalDevicePushDescriptorPropertiesKHR()
+ {}
+
+ PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this) = rhs;
+ }
+
+ PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
+ void* pNext = nullptr;
+ uint32_t maxPushDescriptors;
+ };
+ static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDevicePushDescriptorPropertiesKHR : public layout::PhysicalDevicePushDescriptorPropertiesKHR
+ {
+ PhysicalDevicePushDescriptorPropertiesKHR()
+ : layout::PhysicalDevicePushDescriptorPropertiesKHR()
+ {}
+
+ PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
+ : layout::PhysicalDevicePushDescriptorPropertiesKHR( rhs )
+ {}
+
+ PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
+ {
+ layout::PhysicalDevicePushDescriptorPropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const
{
return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>( this );
@@ -40267,16 +50620,61 @@
}
private:
- StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
-
- public:
- void* pNext = nullptr;
- uint32_t maxPushDescriptors;
+ using layout::PhysicalDevicePushDescriptorPropertiesKHR::sType;
};
static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDevicePushDescriptorPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceRayTracingPropertiesNV
+ namespace layout
{
+ struct PhysicalDeviceRayTracingPropertiesNV
+ {
+ protected:
+ PhysicalDeviceRayTracingPropertiesNV()
+ {}
+
+ PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
+ void* pNext = nullptr;
+ uint32_t shaderGroupHandleSize;
+ uint32_t maxRecursionDepth;
+ uint32_t maxShaderGroupStride;
+ uint32_t shaderGroupBaseAlignment;
+ uint64_t maxGeometryCount;
+ uint64_t maxInstanceCount;
+ uint64_t maxTriangleCount;
+ uint32_t maxDescriptorSetAccelerationStructures;
+ };
+ static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceRayTracingPropertiesNV : public layout::PhysicalDeviceRayTracingPropertiesNV
+ {
+ PhysicalDeviceRayTracingPropertiesNV()
+ : layout::PhysicalDeviceRayTracingPropertiesNV()
+ {}
+
+ PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
+ : layout::PhysicalDeviceRayTracingPropertiesNV( rhs )
+ {}
+
+ PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs )
+ {
+ layout::PhysicalDeviceRayTracingPropertiesNV::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceRayTracingPropertiesNV const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>( this );
@@ -40307,35 +50705,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV;
-
- public:
- void* pNext = nullptr;
- uint32_t shaderGroupHandleSize;
- uint32_t maxRecursionDepth;
- uint32_t maxShaderGroupStride;
- uint32_t shaderGroupBaseAlignment;
- uint64_t maxGeometryCount;
- uint64_t maxInstanceCount;
- uint64_t maxTriangleCount;
- uint32_t maxDescriptorSetAccelerationStructures;
+ using layout::PhysicalDeviceRayTracingPropertiesNV::sType;
};
static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceRayTracingPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
+ namespace layout
{
- PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = 0 )
- : representativeFragmentTest( representativeFragmentTest_ )
+ struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 )
+ : representativeFragmentTest( representativeFragmentTest_ )
+ {}
+
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 representativeFragmentTest;
+ };
+ static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV : public layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 )
+ : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( representativeFragmentTest_ )
{}
PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
- }
+ : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( rhs )
+ {}
PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) );
+ layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(rhs);
return *this;
}
@@ -40345,7 +50760,7 @@
return *this;
}
- PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ )
+ PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( vk::Bool32 representativeFragmentTest_ )
{
representativeFragmentTest = representativeFragmentTest_;
return *this;
@@ -40374,16 +50789,58 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 representativeFragmentTest;
+ using layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceSampleLocationsPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceSampleLocationsPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceSampleLocationsPropertiesEXT()
+ {}
+
+ PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
+ void* pNext = nullptr;
+ vk::SampleCountFlags sampleLocationSampleCounts;
+ vk::Extent2D maxSampleLocationGridSize;
+ float sampleLocationCoordinateRange[2];
+ uint32_t sampleLocationSubPixelBits;
+ vk::Bool32 variableSampleLocations;
+ };
+ static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSampleLocationsPropertiesEXT : public layout::PhysicalDeviceSampleLocationsPropertiesEXT
+ {
+ PhysicalDeviceSampleLocationsPropertiesEXT()
+ : layout::PhysicalDeviceSampleLocationsPropertiesEXT()
+ {}
+
+ PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceSampleLocationsPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceSampleLocationsPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this );
@@ -40411,20 +50868,55 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- SampleCountFlags sampleLocationSampleCounts;
- Extent2D maxSampleLocationGridSize;
- float sampleLocationCoordinateRange[2];
- uint32_t sampleLocationSubPixelBits;
- Bool32 variableSampleLocations;
+ using layout::PhysicalDeviceSampleLocationsPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSampleLocationsPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+ {}
+
+ PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 filterMinmaxSingleComponentFormats;
+ vk::Bool32 filterMinmaxImageComponentMapping;
+ };
+ static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT : public layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
+ {
+ PhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+ : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+ {}
+
+ PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>( this );
@@ -40449,29 +50941,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 filterMinmaxSingleComponentFormats;
- Bool32 filterMinmaxImageComponentMapping;
+ using layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceSamplerYcbcrConversionFeatures
+ namespace layout
{
- PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = 0 )
- : samplerYcbcrConversion( samplerYcbcrConversion_ )
+ struct PhysicalDeviceSamplerYcbcrConversionFeatures
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 )
+ : samplerYcbcrConversion( samplerYcbcrConversion_ )
+ {}
+
+ PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
+ }
+
+ PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
+ void* pNext = nullptr;
+ vk::Bool32 samplerYcbcrConversion;
+ };
+ static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSamplerYcbcrConversionFeatures : public layout::PhysicalDeviceSamplerYcbcrConversionFeatures
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 )
+ : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( samplerYcbcrConversion_ )
{}
PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
- }
+ : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( rhs )
+ {}
PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) );
+ layout::PhysicalDeviceSamplerYcbcrConversionFeatures::operator=(rhs);
return *this;
}
@@ -40481,7 +50996,7 @@
return *this;
}
- PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ )
+ PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( vk::Bool32 samplerYcbcrConversion_ )
{
samplerYcbcrConversion = samplerYcbcrConversion_;
return *this;
@@ -40510,28 +51025,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures;
-
- public:
- void* pNext = nullptr;
- Bool32 samplerYcbcrConversion;
+ using layout::PhysicalDeviceSamplerYcbcrConversionFeatures::sType;
};
static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSamplerYcbcrConversionFeatures>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
+ namespace layout
{
- PhysicalDeviceScalarBlockLayoutFeaturesEXT( Bool32 scalarBlockLayout_ = 0 )
- : scalarBlockLayout( scalarBlockLayout_ )
+ struct PhysicalDeviceScalarBlockLayoutFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 )
+ : scalarBlockLayout( scalarBlockLayout_ )
+ {}
+
+ PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 scalarBlockLayout;
+ };
+ static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceScalarBlockLayoutFeaturesEXT : public layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 )
+ : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( scalarBlockLayout_ )
{}
PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( rhs )
+ {}
PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) );
+ layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::operator=(rhs);
return *this;
}
@@ -40541,7 +51080,7 @@
return *this;
}
- PhysicalDeviceScalarBlockLayoutFeaturesEXT & setScalarBlockLayout( Bool32 scalarBlockLayout_ )
+ PhysicalDeviceScalarBlockLayoutFeaturesEXT & setScalarBlockLayout( vk::Bool32 scalarBlockLayout_ )
{
scalarBlockLayout = scalarBlockLayout_;
return *this;
@@ -40570,30 +51109,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 scalarBlockLayout;
+ using layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceScalarBlockLayoutFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
+ namespace layout
{
- PhysicalDeviceShaderAtomicInt64FeaturesKHR( Bool32 shaderBufferInt64Atomics_ = 0,
- Bool32 shaderSharedInt64Atomics_ = 0 )
- : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
- , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
+ struct PhysicalDeviceShaderAtomicInt64FeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0,
+ vk::Bool32 shaderSharedInt64Atomics_ = 0 )
+ : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
+ , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
+ {}
+
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 shaderBufferInt64Atomics;
+ vk::Bool32 shaderSharedInt64Atomics;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderAtomicInt64FeaturesKHR : public layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0,
+ vk::Bool32 shaderSharedInt64Atomics_ = 0 )
+ : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( shaderBufferInt64Atomics_, shaderSharedInt64Atomics_ )
{}
PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
- }
+ : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( rhs )
+ {}
PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
+ layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::operator=(rhs);
return *this;
}
@@ -40603,13 +51168,13 @@
return *this;
}
- PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics( vk::Bool32 shaderBufferInt64Atomics_ )
{
shaderBufferInt64Atomics = shaderBufferInt64Atomics_;
return *this;
}
- PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ )
+ PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics( vk::Bool32 shaderSharedInt64Atomics_ )
{
shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
return *this;
@@ -40639,17 +51204,235 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR;
-
- public:
- void* pNext = nullptr;
- Bool32 shaderBufferInt64Atomics;
- Bool32 shaderSharedInt64Atomics;
+ using layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::sType;
};
static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderAtomicInt64FeaturesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderCorePropertiesAMD
+ namespace layout
{
+ struct PhysicalDeviceShaderClockFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0,
+ vk::Bool32 shaderDeviceClock_ = 0 )
+ : shaderSubgroupClock( shaderSubgroupClock_ )
+ , shaderDeviceClock( shaderDeviceClock_ )
+ {}
+
+ PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 shaderSubgroupClock;
+ vk::Bool32 shaderDeviceClock;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderClockFeaturesKHR : public layout::PhysicalDeviceShaderClockFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0,
+ vk::Bool32 shaderDeviceClock_ = 0 )
+ : layout::PhysicalDeviceShaderClockFeaturesKHR( shaderSubgroupClock_, shaderDeviceClock_ )
+ {}
+
+ PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs )
+ : layout::PhysicalDeviceShaderClockFeaturesKHR( rhs )
+ {}
+
+ PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs )
+ {
+ layout::PhysicalDeviceShaderClockFeaturesKHR::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceShaderClockFeaturesKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceShaderClockFeaturesKHR & setShaderSubgroupClock( vk::Bool32 shaderSubgroupClock_ )
+ {
+ shaderSubgroupClock = shaderSubgroupClock_;
+ return *this;
+ }
+
+ PhysicalDeviceShaderClockFeaturesKHR & setShaderDeviceClock( vk::Bool32 shaderDeviceClock_ )
+ {
+ shaderDeviceClock = shaderDeviceClock_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceShaderClockFeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDeviceShaderClockFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDeviceShaderClockFeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( shaderSubgroupClock == rhs.shaderSubgroupClock )
+ && ( shaderDeviceClock == rhs.shaderDeviceClock );
+ }
+
+ bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceShaderClockFeaturesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderClockFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceShaderCoreProperties2AMD
+ {
+ protected:
+ PhysicalDeviceShaderCoreProperties2AMD()
+ {}
+
+ PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD;
+ void* pNext = nullptr;
+ vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+ uint32_t activeComputeUnitCount;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderCoreProperties2AMD : public layout::PhysicalDeviceShaderCoreProperties2AMD
+ {
+ PhysicalDeviceShaderCoreProperties2AMD()
+ : layout::PhysicalDeviceShaderCoreProperties2AMD()
+ {}
+
+ PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs )
+ : layout::PhysicalDeviceShaderCoreProperties2AMD( rhs )
+ {}
+
+ PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs )
+ {
+ layout::PhysicalDeviceShaderCoreProperties2AMD::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPhysicalDeviceShaderCoreProperties2AMD const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>( this );
+ }
+
+ operator VkPhysicalDeviceShaderCoreProperties2AMD &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>( this );
+ }
+
+ bool operator==( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( shaderCoreFeatures == rhs.shaderCoreFeatures )
+ && ( activeComputeUnitCount == rhs.activeComputeUnitCount );
+ }
+
+ bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceShaderCoreProperties2AMD::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderCoreProperties2AMD>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceShaderCorePropertiesAMD
+ {
+ protected:
+ PhysicalDeviceShaderCorePropertiesAMD()
+ {}
+
+ PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
+ void* pNext = nullptr;
+ uint32_t shaderEngineCount;
+ uint32_t shaderArraysPerEngineCount;
+ uint32_t computeUnitsPerShaderArray;
+ uint32_t simdPerComputeUnit;
+ uint32_t wavefrontsPerSimd;
+ uint32_t wavefrontSize;
+ uint32_t sgprsPerSimd;
+ uint32_t minSgprAllocation;
+ uint32_t maxSgprAllocation;
+ uint32_t sgprAllocationGranularity;
+ uint32_t vgprsPerSimd;
+ uint32_t minVgprAllocation;
+ uint32_t maxVgprAllocation;
+ uint32_t vgprAllocationGranularity;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderCorePropertiesAMD : public layout::PhysicalDeviceShaderCorePropertiesAMD
+ {
+ PhysicalDeviceShaderCorePropertiesAMD()
+ : layout::PhysicalDeviceShaderCorePropertiesAMD()
+ {}
+
+ PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs )
+ : layout::PhysicalDeviceShaderCorePropertiesAMD( rhs )
+ {}
+
+ PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs )
+ {
+ layout::PhysicalDeviceShaderCorePropertiesAMD::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>( this );
@@ -40686,41 +51469,136 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD;
-
- public:
- void* pNext = nullptr;
- uint32_t shaderEngineCount;
- uint32_t shaderArraysPerEngineCount;
- uint32_t computeUnitsPerShaderArray;
- uint32_t simdPerComputeUnit;
- uint32_t wavefrontsPerSimd;
- uint32_t wavefrontSize;
- uint32_t sgprsPerSimd;
- uint32_t minSgprAllocation;
- uint32_t maxSgprAllocation;
- uint32_t sgprAllocationGranularity;
- uint32_t vgprsPerSimd;
- uint32_t minVgprAllocation;
- uint32_t maxVgprAllocation;
- uint32_t vgprAllocationGranularity;
+ using layout::PhysicalDeviceShaderCorePropertiesAMD::sType;
};
static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderCorePropertiesAMD>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderDrawParametersFeatures
+ namespace layout
{
- PhysicalDeviceShaderDrawParametersFeatures( Bool32 shaderDrawParameters_ = 0 )
- : shaderDrawParameters( shaderDrawParameters_ )
+ struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 )
+ : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ )
+ {}
+
+ PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 shaderDemoteToHelperInvocation;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : public layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 )
+ : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( shaderDemoteToHelperInvocation_ )
+ {}
+
+ PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
+ : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & setShaderDemoteToHelperInvocation( vk::Bool32 shaderDemoteToHelperInvocation_ )
+ {
+ shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation );
+ }
+
+ bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceShaderDrawParametersFeatures
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 )
+ : shaderDrawParameters( shaderDrawParameters_ )
+ {}
+
+ PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
+ void* pNext = nullptr;
+ vk::Bool32 shaderDrawParameters;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderDrawParametersFeatures : public layout::PhysicalDeviceShaderDrawParametersFeatures
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 )
+ : layout::PhysicalDeviceShaderDrawParametersFeatures( shaderDrawParameters_ )
{}
PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParametersFeatures ) );
- }
+ : layout::PhysicalDeviceShaderDrawParametersFeatures( rhs )
+ {}
PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParametersFeatures ) );
+ layout::PhysicalDeviceShaderDrawParametersFeatures::operator=(rhs);
return *this;
}
@@ -40730,7 +51608,7 @@
return *this;
}
- PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ )
+ PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( vk::Bool32 shaderDrawParameters_ )
{
shaderDrawParameters = shaderDrawParameters_;
return *this;
@@ -40759,28 +51637,147 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures;
-
- public:
- void* pNext = nullptr;
- Bool32 shaderDrawParameters;
+ using layout::PhysicalDeviceShaderDrawParametersFeatures::sType;
};
static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderDrawParametersFeatures>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderImageFootprintFeaturesNV
+ namespace layout
{
- PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = 0 )
- : imageFootprint( imageFootprint_ )
+ struct PhysicalDeviceShaderFloat16Int8FeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0,
+ vk::Bool32 shaderInt8_ = 0 )
+ : shaderFloat16( shaderFloat16_ )
+ , shaderInt8( shaderInt8_ )
+ {}
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 shaderFloat16;
+ vk::Bool32 shaderInt8;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderFloat16Int8FeaturesKHR : public layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0,
+ vk::Bool32 shaderInt8_ = 0 )
+ : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( shaderFloat16_, shaderInt8_ )
+ {}
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+ : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( rhs )
+ {}
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs )
+ {
+ layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR & setShaderFloat16( vk::Bool32 shaderFloat16_ )
+ {
+ shaderFloat16 = shaderFloat16_;
+ return *this;
+ }
+
+ PhysicalDeviceShaderFloat16Int8FeaturesKHR & setShaderInt8( vk::Bool32 shaderInt8_ )
+ {
+ shaderInt8 = shaderInt8_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDeviceShaderFloat16Int8FeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDeviceShaderFloat16Int8FeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( shaderFloat16 == rhs.shaderFloat16 )
+ && ( shaderInt8 == rhs.shaderInt8 );
+ }
+
+ bool operator!=( PhysicalDeviceShaderFloat16Int8FeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderFloat16Int8FeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceShaderImageFootprintFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 )
+ : imageFootprint( imageFootprint_ )
+ {}
+
+ PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 imageFootprint;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderImageFootprintFeaturesNV : public layout::PhysicalDeviceShaderImageFootprintFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 )
+ : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( imageFootprint_ )
{}
PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
- }
+ : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( rhs )
+ {}
PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) );
+ layout::PhysicalDeviceShaderImageFootprintFeaturesNV::operator=(rhs);
return *this;
}
@@ -40790,7 +51787,7 @@
return *this;
}
- PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( Bool32 imageFootprint_ )
+ PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( vk::Bool32 imageFootprint_ )
{
imageFootprint = imageFootprint_;
return *this;
@@ -40819,88 +51816,136 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 imageFootprint;
+ using layout::PhysicalDeviceShaderImageFootprintFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderImageFootprintFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderIntegerFunctions2INTEL
+ namespace layout
{
- PhysicalDeviceShaderIntegerFunctions2INTEL( Bool32 shaderIntegerFunctions2_ = 0 )
- : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
+ struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 )
+ : shaderIntegerFunctions2( shaderIntegerFunctions2_ )
+ {}
+
+ PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
+ void* pNext = nullptr;
+ vk::Bool32 shaderIntegerFunctions2;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : public layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 )
+ : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( shaderIntegerFunctions2_ )
{}
- PhysicalDeviceShaderIntegerFunctions2INTEL( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) );
- }
+ PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
+ : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( rhs )
+ {}
- PhysicalDeviceShaderIntegerFunctions2INTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2INTEL const & rhs )
+ PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) );
+ layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(rhs);
return *this;
}
- PhysicalDeviceShaderIntegerFunctions2INTEL & setPNext( void* pNext_ )
+ PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setPNext( void* pNext_ )
{
pNext = pNext_;
return *this;
}
- PhysicalDeviceShaderIntegerFunctions2INTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ )
+ PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setShaderIntegerFunctions2( vk::Bool32 shaderIntegerFunctions2_ )
{
shaderIntegerFunctions2 = shaderIntegerFunctions2_;
return *this;
}
- operator VkPhysicalDeviceShaderIntegerFunctions2INTEL const&() const
+ operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const&() const
{
- return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2INTEL*>( this );
+ return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this );
}
- operator VkPhysicalDeviceShaderIntegerFunctions2INTEL &()
+ operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &()
{
- return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2INTEL*>( this );
+ return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this );
}
- bool operator==( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const
+ bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) const
{
return ( sType == rhs.sType )
&& ( pNext == rhs.pNext )
&& ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 );
}
- bool operator!=( PhysicalDeviceShaderIntegerFunctions2INTEL const& rhs ) const
+ bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& rhs ) const
{
return !operator==( rhs );
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
-
- public:
- void* pNext = nullptr;
- Bool32 shaderIntegerFunctions2;
+ using layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::sType;
};
- static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2INTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2INTEL ), "struct and wrapper have different size!" );
+ static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
+ namespace layout
{
- PhysicalDeviceShaderSMBuiltinsFeaturesNV( Bool32 shaderSMBuiltins_ = 0 )
- : shaderSMBuiltins( shaderSMBuiltins_ )
+ struct PhysicalDeviceShaderSMBuiltinsFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 )
+ : shaderSMBuiltins( shaderSMBuiltins_ )
+ {}
+
+ PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 shaderSMBuiltins;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderSMBuiltinsFeaturesNV : public layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 )
+ : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( shaderSMBuiltins_ )
{}
PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) );
- }
+ : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( rhs )
+ {}
PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) );
+ layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(rhs);
return *this;
}
@@ -40910,7 +51955,7 @@
return *this;
}
- PhysicalDeviceShaderSMBuiltinsFeaturesNV & setShaderSMBuiltins( Bool32 shaderSMBuiltins_ )
+ PhysicalDeviceShaderSMBuiltinsFeaturesNV & setShaderSMBuiltins( vk::Bool32 shaderSMBuiltins_ )
{
shaderSMBuiltins = shaderSMBuiltins_;
return *this;
@@ -40939,16 +51984,55 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 shaderSMBuiltins;
+ using layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
+ namespace layout
{
+ struct PhysicalDeviceShaderSMBuiltinsPropertiesNV
+ {
+ protected:
+ PhysicalDeviceShaderSMBuiltinsPropertiesNV()
+ {}
+
+ PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
+ void* pNext = nullptr;
+ uint32_t shaderSMCount;
+ uint32_t shaderWarpsPerSM;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderSMBuiltinsPropertiesNV : public layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV
+ {
+ PhysicalDeviceShaderSMBuiltinsPropertiesNV()
+ : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV()
+ {}
+
+ PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs )
+ : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV( rhs )
+ {}
+
+ PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs )
+ {
+ layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>( this );
@@ -40973,31 +52057,140 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV;
-
- public:
- void* pNext = nullptr;
- uint32_t shaderSMCount;
- uint32_t shaderWarpsPerSM;
+ using layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::sType;
};
static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShadingRateImageFeaturesNV
+ namespace layout
{
- PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = 0,
- Bool32 shadingRateCoarseSampleOrder_ = 0 )
- : shadingRateImage( shadingRateImage_ )
- , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
+ struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 )
+ : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ )
+ {}
+
+ PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 shaderSubgroupExtendedTypes;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR : public layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 )
+ : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( shaderSubgroupExtendedTypes_ )
+ {}
+
+ PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs )
+ : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( rhs )
+ {}
+
+ PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs )
+ {
+ layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR & setShaderSubgroupExtendedTypes( vk::Bool32 shaderSubgroupExtendedTypes_ )
+ {
+ shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes );
+ }
+
+ bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceShadingRateImageFeaturesNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0,
+ vk::Bool32 shadingRateCoarseSampleOrder_ = 0 )
+ : shadingRateImage( shadingRateImage_ )
+ , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
+ {}
+
+ PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
+ void* pNext = nullptr;
+ vk::Bool32 shadingRateImage;
+ vk::Bool32 shadingRateCoarseSampleOrder;
+ };
+ static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShadingRateImageFeaturesNV : public layout::PhysicalDeviceShadingRateImageFeaturesNV
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0,
+ vk::Bool32 shadingRateCoarseSampleOrder_ = 0 )
+ : layout::PhysicalDeviceShadingRateImageFeaturesNV( shadingRateImage_, shadingRateCoarseSampleOrder_ )
{}
PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
- }
+ : layout::PhysicalDeviceShadingRateImageFeaturesNV( rhs )
+ {}
PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
+ layout::PhysicalDeviceShadingRateImageFeaturesNV::operator=(rhs);
return *this;
}
@@ -41007,13 +52200,13 @@
return *this;
}
- PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( Bool32 shadingRateImage_ )
+ PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( vk::Bool32 shadingRateImage_ )
{
shadingRateImage = shadingRateImage_;
return *this;
}
- PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ )
+ PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( vk::Bool32 shadingRateCoarseSampleOrder_ )
{
shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
return *this;
@@ -41043,17 +52236,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV;
-
- public:
- void* pNext = nullptr;
- Bool32 shadingRateImage;
- Bool32 shadingRateCoarseSampleOrder;
+ using layout::PhysicalDeviceShadingRateImageFeaturesNV::sType;
};
static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImageFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceShadingRateImagePropertiesNV
+ namespace layout
{
+ struct PhysicalDeviceShadingRateImagePropertiesNV
+ {
+ protected:
+ PhysicalDeviceShadingRateImagePropertiesNV()
+ {}
+
+ PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this) = rhs;
+ }
+
+ PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
+ void* pNext = nullptr;
+ vk::Extent2D shadingRateTexelSize;
+ uint32_t shadingRatePaletteSize;
+ uint32_t shadingRateMaxCoarseSamples;
+ };
+ static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceShadingRateImagePropertiesNV : public layout::PhysicalDeviceShadingRateImagePropertiesNV
+ {
+ PhysicalDeviceShadingRateImagePropertiesNV()
+ : layout::PhysicalDeviceShadingRateImagePropertiesNV()
+ {}
+
+ PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs )
+ : layout::PhysicalDeviceShadingRateImagePropertiesNV( rhs )
+ {}
+
+ PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs )
+ {
+ layout::PhysicalDeviceShadingRateImagePropertiesNV::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>( this );
@@ -41079,38 +52311,68 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV;
-
- public:
- void* pNext = nullptr;
- Extent2D shadingRateTexelSize;
- uint32_t shadingRatePaletteSize;
- uint32_t shadingRateMaxCoarseSamples;
+ using layout::PhysicalDeviceShadingRateImagePropertiesNV::sType;
};
static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImagePropertiesNV>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceSparseImageFormatInfo2
+ namespace layout
{
- PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined,
- ImageType type_ = ImageType::e1D,
- SampleCountFlagBits samples_ = SampleCountFlagBits::e1,
- ImageUsageFlags usage_ = ImageUsageFlags(),
- ImageTiling tiling_ = ImageTiling::eOptimal )
- : format( format_ )
- , type( type_ )
- , samples( samples_ )
- , usage( usage_ )
- , tiling( tiling_ )
+ struct PhysicalDeviceSparseImageFormatInfo2
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+ vk::ImageType type_ = vk::ImageType::e1D,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal )
+ : format( format_ )
+ , type( type_ )
+ , samples( samples_ )
+ , usage( usage_ )
+ , tiling( tiling_ )
+ {}
+
+ PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
+ }
+
+ PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
+ const void* pNext = nullptr;
+ vk::Format format;
+ vk::ImageType type;
+ vk::SampleCountFlagBits samples;
+ vk::ImageUsageFlags usage;
+ vk::ImageTiling tiling;
+ };
+ static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSparseImageFormatInfo2 : public layout::PhysicalDeviceSparseImageFormatInfo2
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined,
+ vk::ImageType type_ = vk::ImageType::e1D,
+ vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1,
+ vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(),
+ vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal )
+ : layout::PhysicalDeviceSparseImageFormatInfo2( format_, type_, samples_, usage_, tiling_ )
{}
PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
- }
+ : layout::PhysicalDeviceSparseImageFormatInfo2( rhs )
+ {}
PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
+ layout::PhysicalDeviceSparseImageFormatInfo2::operator=(rhs);
return *this;
}
@@ -41120,31 +52382,31 @@
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2 & setFormat( Format format_ )
+ PhysicalDeviceSparseImageFormatInfo2 & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2 & setType( ImageType type_ )
+ PhysicalDeviceSparseImageFormatInfo2 & setType( vk::ImageType type_ )
{
type = type_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2 & setSamples( SampleCountFlagBits samples_ )
+ PhysicalDeviceSparseImageFormatInfo2 & setSamples( vk::SampleCountFlagBits samples_ )
{
samples = samples_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2 & setUsage( ImageUsageFlags usage_ )
+ PhysicalDeviceSparseImageFormatInfo2 & setUsage( vk::ImageUsageFlags usage_ )
{
usage = usage_;
return *this;
}
- PhysicalDeviceSparseImageFormatInfo2 & setTiling( ImageTiling tiling_ )
+ PhysicalDeviceSparseImageFormatInfo2 & setTiling( vk::ImageTiling tiling_ )
{
tiling = tiling_;
return *this;
@@ -41177,20 +52439,57 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2;
-
- public:
- const void* pNext = nullptr;
- Format format;
- ImageType type;
- SampleCountFlagBits samples;
- ImageUsageFlags usage;
- ImageTiling tiling;
+ using layout::PhysicalDeviceSparseImageFormatInfo2::sType;
};
static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSparseImageFormatInfo2>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceSubgroupProperties
+ namespace layout
{
+ struct PhysicalDeviceSubgroupProperties
+ {
+ protected:
+ PhysicalDeviceSubgroupProperties()
+ {}
+
+ PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this) = rhs;
+ }
+
+ PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
+ void* pNext = nullptr;
+ uint32_t subgroupSize;
+ vk::ShaderStageFlags supportedStages;
+ vk::SubgroupFeatureFlags supportedOperations;
+ vk::Bool32 quadOperationsInAllStages;
+ };
+ static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSubgroupProperties : public layout::PhysicalDeviceSubgroupProperties
+ {
+ PhysicalDeviceSubgroupProperties()
+ : layout::PhysicalDeviceSubgroupProperties()
+ {}
+
+ PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs )
+ : layout::PhysicalDeviceSubgroupProperties( rhs )
+ {}
+
+ PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs )
+ {
+ layout::PhysicalDeviceSubgroupProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceSubgroupProperties const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>( this );
@@ -41217,31 +52516,224 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties;
-
- public:
- void* pNext = nullptr;
- uint32_t subgroupSize;
- ShaderStageFlags supportedStages;
- SubgroupFeatureFlags supportedOperations;
- Bool32 quadOperationsInAllStages;
+ using layout::PhysicalDeviceSubgroupProperties::sType;
};
static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSubgroupProperties>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceSurfaceInfo2KHR
+ namespace layout
{
- PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
- : surface( surface_ )
+ struct PhysicalDeviceSubgroupSizeControlFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0,
+ vk::Bool32 computeFullSubgroups_ = 0 )
+ : subgroupSizeControl( subgroupSizeControl_ )
+ , computeFullSubgroups( computeFullSubgroups_ )
+ {}
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 subgroupSizeControl;
+ vk::Bool32 computeFullSubgroups;
+ };
+ static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSubgroupSizeControlFeaturesEXT : public layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0,
+ vk::Bool32 computeFullSubgroups_ = 0 )
+ : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( subgroupSizeControl_, computeFullSubgroups_ )
+ {}
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+ : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT & setSubgroupSizeControl( vk::Bool32 subgroupSizeControl_ )
+ {
+ subgroupSizeControl = subgroupSizeControl_;
+ return *this;
+ }
+
+ PhysicalDeviceSubgroupSizeControlFeaturesEXT & setComputeFullSubgroups( vk::Bool32 computeFullSubgroups_ )
+ {
+ computeFullSubgroups = computeFullSubgroups_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( subgroupSizeControl == rhs.subgroupSizeControl )
+ && ( computeFullSubgroups == rhs.computeFullSubgroups );
+ }
+
+ bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceSubgroupSizeControlPropertiesEXT()
+ {}
+
+ PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t minSubgroupSize;
+ uint32_t maxSubgroupSize;
+ uint32_t maxComputeWorkgroupSubgroups;
+ vk::ShaderStageFlags requiredSubgroupSizeStages;
+ };
+ static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSubgroupSizeControlPropertiesEXT : public layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT
+ {
+ PhysicalDeviceSubgroupSizeControlPropertiesEXT()
+ : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT()
+ {}
+
+ PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( minSubgroupSize == rhs.minSubgroupSize )
+ && ( maxSubgroupSize == rhs.maxSubgroupSize )
+ && ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups )
+ && ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages );
+ }
+
+ bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceSurfaceInfo2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() )
+ : surface( surface_ )
+ {}
+
+ PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
+ const void* pNext = nullptr;
+ vk::SurfaceKHR surface;
+ };
+ static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceSurfaceInfo2KHR : public layout::PhysicalDeviceSurfaceInfo2KHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() )
+ : layout::PhysicalDeviceSurfaceInfo2KHR( surface_ )
{}
PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
- }
+ : layout::PhysicalDeviceSurfaceInfo2KHR( rhs )
+ {}
PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
+ layout::PhysicalDeviceSurfaceInfo2KHR::operator=(rhs);
return *this;
}
@@ -41251,7 +52743,7 @@
return *this;
}
- PhysicalDeviceSurfaceInfo2KHR & setSurface( SurfaceKHR surface_ )
+ PhysicalDeviceSurfaceInfo2KHR & setSurface( vk::SurfaceKHR surface_ )
{
surface = surface_;
return *this;
@@ -41280,30 +52772,456 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
-
- public:
- const void* pNext = nullptr;
- SurfaceKHR surface;
+ using layout::PhysicalDeviceSurfaceInfo2KHR::sType;
};
static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceSurfaceInfo2KHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceTransformFeedbackFeaturesEXT
+ namespace layout
{
- PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = 0,
- Bool32 geometryStreams_ = 0 )
- : transformFeedback( transformFeedback_ )
- , geometryStreams( geometryStreams_ )
+ struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 )
+ : texelBufferAlignment( texelBufferAlignment_ )
+ {}
+
+ PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 texelBufferAlignment;
+ };
+ static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT : public layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 )
+ : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( texelBufferAlignment_ )
+ {}
+
+ PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
+ : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setTexelBufferAlignment( vk::Bool32 texelBufferAlignment_ )
+ {
+ texelBufferAlignment = texelBufferAlignment_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( texelBufferAlignment == rhs.texelBufferAlignment );
+ }
+
+ bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceTexelBufferAlignmentPropertiesEXT()
+ {}
+
+ PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+ void* pNext = nullptr;
+ vk::DeviceSize storageTexelBufferOffsetAlignmentBytes;
+ vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment;
+ vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes;
+ vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment;
+ };
+ static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT : public layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT
+ {
+ PhysicalDeviceTexelBufferAlignmentPropertiesEXT()
+ : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT()
+ {}
+
+ PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes )
+ && ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment )
+ && ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes )
+ && ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment );
+ }
+
+ bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 )
+ : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ )
+ {}
+
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT;
+ const void* pNext = nullptr;
+ vk::Bool32 textureCompressionASTC_HDR;
+ };
+ static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT : public layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 )
+ : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( textureCompressionASTC_HDR_ )
+ {}
+
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+ : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs )
+ {}
+
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs )
+ {
+ layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setTextureCompressionASTC_HDR( vk::Bool32 textureCompressionASTC_HDR_ )
+ {
+ textureCompressionASTC_HDR = textureCompressionASTC_HDR_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this );
+ }
+
+ operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this );
+ }
+
+ bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR );
+ }
+
+ bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceTimelineSemaphoreFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 )
+ : timelineSemaphore( timelineSemaphore_ )
+ {}
+
+ PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 timelineSemaphore;
+ };
+ static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTimelineSemaphoreFeaturesKHR : public layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 )
+ : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( timelineSemaphore_ )
+ {}
+
+ PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs )
+ : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( rhs )
+ {}
+
+ PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs )
+ {
+ layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::operator=(rhs);
+ return *this;
+ }
+
+ PhysicalDeviceTimelineSemaphoreFeaturesKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceTimelineSemaphoreFeaturesKHR & setTimelineSemaphore( vk::Bool32 timelineSemaphore_ )
+ {
+ timelineSemaphore = timelineSemaphore_;
+ return *this;
+ }
+
+ operator VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDeviceTimelineSemaphoreFeaturesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDeviceTimelineSemaphoreFeaturesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( timelineSemaphore == rhs.timelineSemaphore );
+ }
+
+ bool operator!=( PhysicalDeviceTimelineSemaphoreFeaturesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphoreFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceTimelineSemaphorePropertiesKHR
+ {
+ protected:
+ PhysicalDeviceTimelineSemaphorePropertiesKHR()
+ {}
+
+ PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR;
+ void* pNext = nullptr;
+ uint64_t maxTimelineSemaphoreValueDifference;
+ };
+ static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTimelineSemaphorePropertiesKHR : public layout::PhysicalDeviceTimelineSemaphorePropertiesKHR
+ {
+ PhysicalDeviceTimelineSemaphorePropertiesKHR()
+ : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR()
+ {}
+
+ PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs )
+ : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR( rhs )
+ {}
+
+ PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs )
+ {
+ layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPhysicalDeviceTimelineSemaphorePropertiesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>( this );
+ }
+
+ operator VkPhysicalDeviceTimelineSemaphorePropertiesKHR &()
+ {
+ return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>( this );
+ }
+
+ bool operator==( PhysicalDeviceTimelineSemaphorePropertiesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference );
+ }
+
+ bool operator!=( PhysicalDeviceTimelineSemaphorePropertiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::sType;
+ };
+ static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphorePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PhysicalDeviceTransformFeedbackFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0,
+ vk::Bool32 geometryStreams_ = 0 )
+ : transformFeedback( transformFeedback_ )
+ , geometryStreams( geometryStreams_ )
+ {}
+
+ PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 transformFeedback;
+ vk::Bool32 geometryStreams;
+ };
+ static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTransformFeedbackFeaturesEXT : public layout::PhysicalDeviceTransformFeedbackFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0,
+ vk::Bool32 geometryStreams_ = 0 )
+ : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( transformFeedback_, geometryStreams_ )
{}
PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( rhs )
+ {}
PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
+ layout::PhysicalDeviceTransformFeedbackFeaturesEXT::operator=(rhs);
return *this;
}
@@ -41313,13 +53231,13 @@
return *this;
}
- PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( Bool32 transformFeedback_ )
+ PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( vk::Bool32 transformFeedback_ )
{
transformFeedback = transformFeedback_;
return *this;
}
- PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( Bool32 geometryStreams_ )
+ PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( vk::Bool32 geometryStreams_ )
{
geometryStreams = geometryStreams_;
return *this;
@@ -41349,17 +53267,63 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 transformFeedback;
- Bool32 geometryStreams;
+ using layout::PhysicalDeviceTransformFeedbackFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceTransformFeedbackPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceTransformFeedbackPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceTransformFeedbackPropertiesEXT()
+ {}
+
+ PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t maxTransformFeedbackStreams;
+ uint32_t maxTransformFeedbackBuffers;
+ vk::DeviceSize maxTransformFeedbackBufferSize;
+ uint32_t maxTransformFeedbackStreamDataSize;
+ uint32_t maxTransformFeedbackBufferDataSize;
+ uint32_t maxTransformFeedbackBufferDataStride;
+ vk::Bool32 transformFeedbackQueries;
+ vk::Bool32 transformFeedbackStreamsLinesTriangles;
+ vk::Bool32 transformFeedbackRasterizationStreamSelect;
+ vk::Bool32 transformFeedbackDraw;
+ };
+ static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceTransformFeedbackPropertiesEXT : public layout::PhysicalDeviceTransformFeedbackPropertiesEXT
+ {
+ PhysicalDeviceTransformFeedbackPropertiesEXT()
+ : layout::PhysicalDeviceTransformFeedbackPropertiesEXT()
+ {}
+
+ PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceTransformFeedbackPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceTransformFeedbackPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this );
@@ -41392,37 +53356,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t maxTransformFeedbackStreams;
- uint32_t maxTransformFeedbackBuffers;
- DeviceSize maxTransformFeedbackBufferSize;
- uint32_t maxTransformFeedbackStreamDataSize;
- uint32_t maxTransformFeedbackBufferDataSize;
- uint32_t maxTransformFeedbackBufferDataStride;
- Bool32 transformFeedbackQueries;
- Bool32 transformFeedbackStreamsLinesTriangles;
- Bool32 transformFeedbackRasterizationStreamSelect;
- Bool32 transformFeedbackDraw;
+ using layout::PhysicalDeviceTransformFeedbackPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
+ namespace layout
{
- PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( Bool32 uniformBufferStandardLayout_ = 0 )
- : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
+ struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 )
+ : uniformBufferStandardLayout( uniformBufferStandardLayout_ )
+ {}
+
+ PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 uniformBufferStandardLayout;
+ };
+ static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR : public layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 )
+ : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( uniformBufferStandardLayout_ )
{}
PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) );
- }
+ : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( rhs )
+ {}
PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) );
+ layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::operator=(rhs);
return *this;
}
@@ -41432,7 +53411,7 @@
return *this;
}
- PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ )
+ PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & setUniformBufferStandardLayout( vk::Bool32 uniformBufferStandardLayout_ )
{
uniformBufferStandardLayout = uniformBufferStandardLayout_;
return *this;
@@ -41461,30 +53440,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
-
- public:
- void* pNext = nullptr;
- Bool32 uniformBufferStandardLayout;
+ using layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::sType;
};
static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceVariablePointersFeatures
+ namespace layout
{
- PhysicalDeviceVariablePointersFeatures( Bool32 variablePointersStorageBuffer_ = 0,
- Bool32 variablePointers_ = 0 )
- : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
- , variablePointers( variablePointers_ )
+ struct PhysicalDeviceVariablePointersFeatures
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0,
+ vk::Bool32 variablePointers_ = 0 )
+ : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
+ , variablePointers( variablePointers_ )
+ {}
+
+ PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
+ }
+
+ PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures;
+ void* pNext = nullptr;
+ vk::Bool32 variablePointersStorageBuffer;
+ vk::Bool32 variablePointers;
+ };
+ static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceVariablePointersFeatures : public layout::PhysicalDeviceVariablePointersFeatures
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0,
+ vk::Bool32 variablePointers_ = 0 )
+ : layout::PhysicalDeviceVariablePointersFeatures( variablePointersStorageBuffer_, variablePointers_ )
{}
PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointersFeatures ) );
- }
+ : layout::PhysicalDeviceVariablePointersFeatures( rhs )
+ {}
PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointersFeatures ) );
+ layout::PhysicalDeviceVariablePointersFeatures::operator=(rhs);
return *this;
}
@@ -41494,13 +53499,13 @@
return *this;
}
- PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ )
+ PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( vk::Bool32 variablePointersStorageBuffer_ )
{
variablePointersStorageBuffer = variablePointersStorageBuffer_;
return *this;
}
- PhysicalDeviceVariablePointersFeatures & setVariablePointers( Bool32 variablePointers_ )
+ PhysicalDeviceVariablePointersFeatures & setVariablePointers( vk::Bool32 variablePointers_ )
{
variablePointers = variablePointers_;
return *this;
@@ -41530,31 +53535,56 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures;
-
- public:
- void* pNext = nullptr;
- Bool32 variablePointersStorageBuffer;
- Bool32 variablePointers;
+ using layout::PhysicalDeviceVariablePointersFeatures::sType;
};
static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceVariablePointersFeatures>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
+ namespace layout
{
- PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0,
- Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
- : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
- , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
+ struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0,
+ vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
+ : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
+ , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
+ {}
+
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 vertexAttributeInstanceRateDivisor;
+ vk::Bool32 vertexAttributeInstanceRateZeroDivisor;
+ };
+ static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT : public layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0,
+ vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
+ : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vertexAttributeInstanceRateDivisor_, vertexAttributeInstanceRateZeroDivisor_ )
{}
PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( rhs )
+ {}
PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) );
+ layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::operator=(rhs);
return *this;
}
@@ -41564,13 +53594,13 @@
return *this;
}
- PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor( vk::Bool32 vertexAttributeInstanceRateDivisor_ )
{
vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_;
return *this;
}
- PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ )
+ PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor( vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ )
{
vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
return *this;
@@ -41600,17 +53630,54 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 vertexAttributeInstanceRateDivisor;
- Bool32 vertexAttributeInstanceRateZeroDivisor;
+ using layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
+ namespace layout
{
+ struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
+ {
+ protected:
+ PhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+ {}
+
+ PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+ void* pNext = nullptr;
+ uint32_t maxVertexAttribDivisor;
+ };
+ static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT : public layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT
+ {
+ PhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+ : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+ {}
+
+ PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+ : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT( rhs )
+ {}
+
+ PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs )
+ {
+ layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(rhs);
+ return *this;
+ }
+
operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const
{
return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this );
@@ -41634,32 +53701,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT;
-
- public:
- void* pNext = nullptr;
- uint32_t maxVertexAttribDivisor;
+ using layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
+ namespace layout
{
- PhysicalDeviceVulkanMemoryModelFeaturesKHR( Bool32 vulkanMemoryModel_ = 0,
- Bool32 vulkanMemoryModelDeviceScope_ = 0,
- Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 )
- : vulkanMemoryModel( vulkanMemoryModel_ )
- , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ )
- , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
+ struct PhysicalDeviceVulkanMemoryModelFeaturesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0,
+ vk::Bool32 vulkanMemoryModelDeviceScope_ = 0,
+ vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 )
+ : vulkanMemoryModel( vulkanMemoryModel_ )
+ , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ )
+ , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ )
+ {}
+
+ PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
+ }
+
+ PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
+ void* pNext = nullptr;
+ vk::Bool32 vulkanMemoryModel;
+ vk::Bool32 vulkanMemoryModelDeviceScope;
+ vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains;
+ };
+ static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceVulkanMemoryModelFeaturesKHR : public layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0,
+ vk::Bool32 vulkanMemoryModelDeviceScope_ = 0,
+ vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 )
+ : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( vulkanMemoryModel_, vulkanMemoryModelDeviceScope_, vulkanMemoryModelAvailabilityVisibilityChains_ )
{}
PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) );
- }
+ : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( rhs )
+ {}
PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) );
+ layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::operator=(rhs);
return *this;
}
@@ -41669,19 +53764,19 @@
return *this;
}
- PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ )
+ PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModel( vk::Bool32 vulkanMemoryModel_ )
{
vulkanMemoryModel = vulkanMemoryModel_;
return *this;
}
- PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ )
+ PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelDeviceScope( vk::Bool32 vulkanMemoryModelDeviceScope_ )
{
vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_;
return *this;
}
- PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ )
+ PhysicalDeviceVulkanMemoryModelFeaturesKHR & setVulkanMemoryModelAvailabilityVisibilityChains( vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ )
{
vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_;
return *this;
@@ -41712,30 +53807,52 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR;
-
- public:
- void* pNext = nullptr;
- Bool32 vulkanMemoryModel;
- Bool32 vulkanMemoryModelDeviceScope;
- Bool32 vulkanMemoryModelAvailabilityVisibilityChains;
+ using layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::sType;
};
static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceVulkanMemoryModelFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
- struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
+ namespace layout
{
- PhysicalDeviceYcbcrImageArraysFeaturesEXT( Bool32 ycbcrImageArrays_ = 0 )
- : ycbcrImageArrays( ycbcrImageArrays_ )
+ struct PhysicalDeviceYcbcrImageArraysFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 )
+ : ycbcrImageArrays( ycbcrImageArrays_ )
+ {}
+
+ PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
+ }
+
+ PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
+ void* pNext = nullptr;
+ vk::Bool32 ycbcrImageArrays;
+ };
+ static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PhysicalDeviceYcbcrImageArraysFeaturesEXT : public layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 )
+ : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( ycbcrImageArrays_ )
{}
PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) );
- }
+ : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( rhs )
+ {}
PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) );
+ layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(rhs);
return *this;
}
@@ -41745,7 +53862,7 @@
return *this;
}
- PhysicalDeviceYcbcrImageArraysFeaturesEXT & setYcbcrImageArrays( Bool32 ycbcrImageArrays_ )
+ PhysicalDeviceYcbcrImageArraysFeaturesEXT & setYcbcrImageArrays( vk::Bool32 ycbcrImageArrays_ )
{
ycbcrImageArrays = ycbcrImageArrays_;
return *this;
@@ -41774,32 +53891,60 @@
}
private:
- StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 ycbcrImageArrays;
+ using layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::sType;
};
static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PhysicalDeviceYcbcrImageArraysFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineCacheCreateInfo
+ namespace layout
{
- PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(),
- size_t initialDataSize_ = 0,
- const void* pInitialData_ = nullptr )
- : flags( flags_ )
- , initialDataSize( initialDataSize_ )
- , pInitialData( pInitialData_ )
+ struct PipelineCacheCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(),
+ size_t initialDataSize_ = 0,
+ const void* pInitialData_ = nullptr )
+ : flags( flags_ )
+ , initialDataSize( initialDataSize_ )
+ , pInitialData( pInitialData_ )
+ {}
+
+ PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCacheCreateInfo*>(this) = rhs;
+ }
+
+ PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCacheCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineCacheCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineCacheCreateFlags flags;
+ size_t initialDataSize;
+ const void* pInitialData;
+ };
+ static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineCacheCreateInfo : public layout::PipelineCacheCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(),
+ size_t initialDataSize_ = 0,
+ const void* pInitialData_ = nullptr )
+ : layout::PipelineCacheCreateInfo( flags_, initialDataSize_, pInitialData_ )
{}
PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
- }
+ : layout::PipelineCacheCreateInfo( rhs )
+ {}
PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
+ layout::PipelineCacheCreateInfo::operator=(rhs);
return *this;
}
@@ -41809,7 +53954,7 @@
return *this;
}
- PipelineCacheCreateInfo & setFlags( PipelineCacheCreateFlags flags_ )
+ PipelineCacheCreateInfo & setFlags( vk::PipelineCacheCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -41852,34 +53997,60 @@
}
private:
- StructureType sType = StructureType::ePipelineCacheCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineCacheCreateFlags flags;
- size_t initialDataSize;
- const void* pInitialData;
+ using layout::PipelineCacheCreateInfo::sType;
};
static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCacheCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineColorBlendAdvancedStateCreateInfoEXT
+ namespace layout
{
- PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0,
- Bool32 dstPremultiplied_ = 0,
- BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
- : srcPremultiplied( srcPremultiplied_ )
- , dstPremultiplied( dstPremultiplied_ )
- , blendOverlap( blendOverlap_ )
+ struct PipelineColorBlendAdvancedStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0,
+ vk::Bool32 dstPremultiplied_ = 0,
+ vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated )
+ : srcPremultiplied( srcPremultiplied_ )
+ , dstPremultiplied( dstPremultiplied_ )
+ , blendOverlap( blendOverlap_ )
+ {}
+
+ PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::Bool32 srcPremultiplied;
+ vk::Bool32 dstPremultiplied;
+ vk::BlendOverlapEXT blendOverlap;
+ };
+ static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineColorBlendAdvancedStateCreateInfoEXT : public layout::PipelineColorBlendAdvancedStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0,
+ vk::Bool32 dstPremultiplied_ = 0,
+ vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated )
+ : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( srcPremultiplied_, dstPremultiplied_, blendOverlap_ )
{}
PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
- }
+ : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( rhs )
+ {}
PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
+ layout::PipelineColorBlendAdvancedStateCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -41889,19 +54060,19 @@
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( vk::Bool32 srcPremultiplied_ )
{
srcPremultiplied = srcPremultiplied_;
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( Bool32 dstPremultiplied_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( vk::Bool32 dstPremultiplied_ )
{
dstPremultiplied = dstPremultiplied_;
return *this;
}
- PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ )
+ PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( vk::BlendOverlapEXT blendOverlap_ )
{
blendOverlap = blendOverlap_;
return *this;
@@ -41932,38 +54103,152 @@
}
private:
- StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Bool32 srcPremultiplied;
- Bool32 dstPremultiplied;
- BlendOverlapEXT blendOverlap;
+ using layout::PipelineColorBlendAdvancedStateCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineColorBlendAdvancedStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineCoverageModulationStateCreateInfoNV
+ namespace layout
{
- PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(),
- CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone,
- Bool32 coverageModulationTableEnable_ = 0,
- uint32_t coverageModulationTableCount_ = 0,
- const float* pCoverageModulationTable_ = nullptr )
- : flags( flags_ )
- , coverageModulationMode( coverageModulationMode_ )
- , coverageModulationTableEnable( coverageModulationTableEnable_ )
- , coverageModulationTableCount( coverageModulationTableCount_ )
- , pCoverageModulationTable( pCoverageModulationTable_ )
+ struct PipelineCompilerControlCreateInfoAMD
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() )
+ : compilerControlFlags( compilerControlFlags_ )
+ {}
+
+ PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
+ }
+
+ PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD;
+ const void* pNext = nullptr;
+ vk::PipelineCompilerControlFlagsAMD compilerControlFlags;
+ };
+ static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineCompilerControlCreateInfoAMD : public layout::PipelineCompilerControlCreateInfoAMD
+ {
+ VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() )
+ : layout::PipelineCompilerControlCreateInfoAMD( compilerControlFlags_ )
+ {}
+
+ PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+ : layout::PipelineCompilerControlCreateInfoAMD( rhs )
+ {}
+
+ PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs )
+ {
+ layout::PipelineCompilerControlCreateInfoAMD::operator=(rhs);
+ return *this;
+ }
+
+ PipelineCompilerControlCreateInfoAMD & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineCompilerControlCreateInfoAMD & setCompilerControlFlags( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ )
+ {
+ compilerControlFlags = compilerControlFlags_;
+ return *this;
+ }
+
+ operator VkPipelineCompilerControlCreateInfoAMD const&() const
+ {
+ return *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>( this );
+ }
+
+ operator VkPipelineCompilerControlCreateInfoAMD &()
+ {
+ return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>( this );
+ }
+
+ bool operator==( PipelineCompilerControlCreateInfoAMD const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( compilerControlFlags == rhs.compilerControlFlags );
+ }
+
+ bool operator!=( PipelineCompilerControlCreateInfoAMD const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineCompilerControlCreateInfoAMD::sType;
+ };
+ static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCompilerControlCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineCoverageModulationStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(),
+ vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone,
+ vk::Bool32 coverageModulationTableEnable_ = 0,
+ uint32_t coverageModulationTableCount_ = 0,
+ const float* pCoverageModulationTable_ = nullptr )
+ : flags( flags_ )
+ , coverageModulationMode( coverageModulationMode_ )
+ , coverageModulationTableEnable( coverageModulationTableEnable_ )
+ , coverageModulationTableCount( coverageModulationTableCount_ )
+ , pCoverageModulationTable( pCoverageModulationTable_ )
+ {}
+
+ PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::PipelineCoverageModulationStateCreateFlagsNV flags;
+ vk::CoverageModulationModeNV coverageModulationMode;
+ vk::Bool32 coverageModulationTableEnable;
+ uint32_t coverageModulationTableCount;
+ const float* pCoverageModulationTable;
+ };
+ static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineCoverageModulationStateCreateInfoNV : public layout::PipelineCoverageModulationStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(),
+ vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone,
+ vk::Bool32 coverageModulationTableEnable_ = 0,
+ uint32_t coverageModulationTableCount_ = 0,
+ const float* pCoverageModulationTable_ = nullptr )
+ : layout::PipelineCoverageModulationStateCreateInfoNV( flags_, coverageModulationMode_, coverageModulationTableEnable_, coverageModulationTableCount_, pCoverageModulationTable_ )
{}
PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
- }
+ : layout::PipelineCoverageModulationStateCreateInfoNV( rhs )
+ {}
PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
+ layout::PipelineCoverageModulationStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -41973,19 +54258,19 @@
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV & setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
+ PipelineCoverageModulationStateCreateInfoNV & setFlags( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ )
{
flags = flags_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
+ PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( vk::CoverageModulationModeNV coverageModulationMode_ )
{
coverageModulationMode = coverageModulationMode_;
return *this;
}
- PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
+ PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( vk::Bool32 coverageModulationTableEnable_ )
{
coverageModulationTableEnable = coverageModulationTableEnable_;
return *this;
@@ -42030,34 +54315,56 @@
}
private:
- StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- PipelineCoverageModulationStateCreateFlagsNV flags;
- CoverageModulationModeNV coverageModulationMode;
- Bool32 coverageModulationTableEnable;
- uint32_t coverageModulationTableCount;
- const float* pCoverageModulationTable;
+ using layout::PipelineCoverageModulationStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCoverageModulationStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineCoverageReductionStateCreateInfoNV
+ namespace layout
{
- PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateFlagsNV flags_ = PipelineCoverageReductionStateCreateFlagsNV(),
- CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge )
- : flags( flags_ )
- , coverageReductionMode( coverageReductionMode_ )
+ struct PipelineCoverageReductionStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(),
+ vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge )
+ : flags( flags_ )
+ , coverageReductionMode( coverageReductionMode_ )
+ {}
+
+ PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::PipelineCoverageReductionStateCreateFlagsNV flags;
+ vk::CoverageReductionModeNV coverageReductionMode;
+ };
+ static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineCoverageReductionStateCreateInfoNV : public layout::PipelineCoverageReductionStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(),
+ vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge )
+ : layout::PipelineCoverageReductionStateCreateInfoNV( flags_, coverageReductionMode_ )
{}
PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineCoverageReductionStateCreateInfoNV ) );
- }
+ : layout::PipelineCoverageReductionStateCreateInfoNV( rhs )
+ {}
PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCoverageReductionStateCreateInfoNV ) );
+ layout::PipelineCoverageReductionStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -42067,13 +54374,13 @@
return *this;
}
- PipelineCoverageReductionStateCreateInfoNV & setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ )
+ PipelineCoverageReductionStateCreateInfoNV & setFlags( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ )
{
flags = flags_;
return *this;
}
- PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ )
+ PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( vk::CoverageReductionModeNV coverageReductionMode_ )
{
coverageReductionMode = coverageReductionMode_;
return *this;
@@ -42103,33 +54410,60 @@
}
private:
- StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- PipelineCoverageReductionStateCreateFlagsNV flags;
- CoverageReductionModeNV coverageReductionMode;
+ using layout::PipelineCoverageReductionStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCoverageReductionStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineCoverageToColorStateCreateInfoNV
+ namespace layout
{
- PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(),
- Bool32 coverageToColorEnable_ = 0,
- uint32_t coverageToColorLocation_ = 0 )
- : flags( flags_ )
- , coverageToColorEnable( coverageToColorEnable_ )
- , coverageToColorLocation( coverageToColorLocation_ )
+ struct PipelineCoverageToColorStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(),
+ vk::Bool32 coverageToColorEnable_ = 0,
+ uint32_t coverageToColorLocation_ = 0 )
+ : flags( flags_ )
+ , coverageToColorEnable( coverageToColorEnable_ )
+ , coverageToColorLocation( coverageToColorLocation_ )
+ {}
+
+ PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::PipelineCoverageToColorStateCreateFlagsNV flags;
+ vk::Bool32 coverageToColorEnable;
+ uint32_t coverageToColorLocation;
+ };
+ static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineCoverageToColorStateCreateInfoNV : public layout::PipelineCoverageToColorStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(),
+ vk::Bool32 coverageToColorEnable_ = 0,
+ uint32_t coverageToColorLocation_ = 0 )
+ : layout::PipelineCoverageToColorStateCreateInfoNV( flags_, coverageToColorEnable_, coverageToColorLocation_ )
{}
PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
- }
+ : layout::PipelineCoverageToColorStateCreateInfoNV( rhs )
+ {}
PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
+ layout::PipelineCoverageToColorStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -42139,13 +54473,13 @@
return *this;
}
- PipelineCoverageToColorStateCreateInfoNV & setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ )
+ PipelineCoverageToColorStateCreateInfoNV & setFlags( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ )
{
flags = flags_;
return *this;
}
- PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( Bool32 coverageToColorEnable_ )
+ PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( vk::Bool32 coverageToColorEnable_ )
{
coverageToColorEnable = coverageToColorEnable_;
return *this;
@@ -42182,18 +54516,27 @@
}
private:
- StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- PipelineCoverageToColorStateCreateFlagsNV flags;
- Bool32 coverageToColorEnable;
- uint32_t coverageToColorLocation;
+ using layout::PipelineCoverageToColorStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCoverageToColorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
struct PipelineCreationFeedbackEXT
{
+ PipelineCreationFeedbackEXT()
+ {}
+
+ PipelineCreationFeedbackEXT( VkPipelineCreationFeedbackEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCreationFeedbackEXT*>(this) = rhs;
+ }
+
+ PipelineCreationFeedbackEXT& operator=( VkPipelineCreationFeedbackEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCreationFeedbackEXT*>(this) = rhs;
+ return *this;
+ }
+
operator VkPipelineCreationFeedbackEXT const&() const
{
return *reinterpret_cast<const VkPipelineCreationFeedbackEXT*>( this );
@@ -42215,29 +54558,62 @@
return !operator==( rhs );
}
- PipelineCreationFeedbackFlagsEXT flags;
+ public:
+ vk::PipelineCreationFeedbackFlagsEXT flags;
uint64_t duration;
};
static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCreationFeedbackEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineCreationFeedbackCreateInfoEXT
+ namespace layout
{
- PipelineCreationFeedbackCreateInfoEXT( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
- uint32_t pipelineStageCreationFeedbackCount_ = 0,
- PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr )
- : pPipelineCreationFeedback( pPipelineCreationFeedback_ )
- , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ )
- , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
+ struct PipelineCreationFeedbackCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
+ uint32_t pipelineStageCreationFeedbackCount_ = 0,
+ vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr )
+ : pPipelineCreationFeedback( pPipelineCreationFeedback_ )
+ , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ )
+ , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ )
+ {}
+
+ PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback;
+ uint32_t pipelineStageCreationFeedbackCount;
+ vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks;
+ };
+ static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineCreationFeedbackCreateInfoEXT : public layout::PipelineCreationFeedbackCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr,
+ uint32_t pipelineStageCreationFeedbackCount_ = 0,
+ vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr )
+ : layout::PipelineCreationFeedbackCreateInfoEXT( pPipelineCreationFeedback_, pipelineStageCreationFeedbackCount_, pPipelineStageCreationFeedbacks_ )
{}
PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) );
- }
+ : layout::PipelineCreationFeedbackCreateInfoEXT( rhs )
+ {}
PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineCreationFeedbackCreateInfoEXT ) );
+ layout::PipelineCreationFeedbackCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -42247,7 +54623,7 @@
return *this;
}
- PipelineCreationFeedbackCreateInfoEXT & setPPipelineCreationFeedback( PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ )
+ PipelineCreationFeedbackCreateInfoEXT & setPPipelineCreationFeedback( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ )
{
pPipelineCreationFeedback = pPipelineCreationFeedback_;
return *this;
@@ -42259,7 +54635,7 @@
return *this;
}
- PipelineCreationFeedbackCreateInfoEXT & setPPipelineStageCreationFeedbacks( PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ )
+ PipelineCreationFeedbackCreateInfoEXT & setPPipelineStageCreationFeedbacks( vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ )
{
pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_;
return *this;
@@ -42290,36 +54666,64 @@
}
private:
- StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- PipelineCreationFeedbackEXT* pPipelineCreationFeedback;
- uint32_t pipelineStageCreationFeedbackCount;
- PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks;
+ using layout::PipelineCreationFeedbackCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineCreationFeedbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineDiscardRectangleStateCreateInfoEXT
+ namespace layout
{
- PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(),
- DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive,
- uint32_t discardRectangleCount_ = 0,
- const Rect2D* pDiscardRectangles_ = nullptr )
- : flags( flags_ )
- , discardRectangleMode( discardRectangleMode_ )
- , discardRectangleCount( discardRectangleCount_ )
- , pDiscardRectangles( pDiscardRectangles_ )
+ struct PipelineDiscardRectangleStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(),
+ vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive,
+ uint32_t discardRectangleCount_ = 0,
+ const vk::Rect2D* pDiscardRectangles_ = nullptr )
+ : flags( flags_ )
+ , discardRectangleMode( discardRectangleMode_ )
+ , discardRectangleCount( discardRectangleCount_ )
+ , pDiscardRectangles( pDiscardRectangles_ )
+ {}
+
+ PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::PipelineDiscardRectangleStateCreateFlagsEXT flags;
+ vk::DiscardRectangleModeEXT discardRectangleMode;
+ uint32_t discardRectangleCount;
+ const vk::Rect2D* pDiscardRectangles;
+ };
+ static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineDiscardRectangleStateCreateInfoEXT : public layout::PipelineDiscardRectangleStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(),
+ vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive,
+ uint32_t discardRectangleCount_ = 0,
+ const vk::Rect2D* pDiscardRectangles_ = nullptr )
+ : layout::PipelineDiscardRectangleStateCreateInfoEXT( flags_, discardRectangleMode_, discardRectangleCount_, pDiscardRectangles_ )
{}
PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
- }
+ : layout::PipelineDiscardRectangleStateCreateInfoEXT( rhs )
+ {}
PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
+ layout::PipelineDiscardRectangleStateCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -42329,13 +54733,13 @@
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT & setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
+ PipelineDiscardRectangleStateCreateInfoEXT & setFlags( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
+ PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( vk::DiscardRectangleModeEXT discardRectangleMode_ )
{
discardRectangleMode = discardRectangleMode_;
return *this;
@@ -42347,7 +54751,7 @@
return *this;
}
- PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
+ PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const vk::Rect2D* pDiscardRectangles_ )
{
pDiscardRectangles = pDiscardRectangles_;
return *this;
@@ -42379,22 +54783,490 @@
}
private:
- StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- PipelineDiscardRectangleStateCreateFlagsEXT flags;
- DiscardRectangleModeEXT discardRectangleMode;
- uint32_t discardRectangleCount;
- const Rect2D* pDiscardRectangles;
+ using layout::PipelineDiscardRectangleStateCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineDiscardRectangleStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineExecutableInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(),
+ uint32_t executableIndex_ = 0 )
+ : pipeline( pipeline_ )
+ , executableIndex( executableIndex_ )
+ {}
+
+ PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutableInfoKHR*>(this) = rhs;
+ }
+
+ PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutableInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR;
+ const void* pNext = nullptr;
+ vk::Pipeline pipeline;
+ uint32_t executableIndex;
+ };
+ static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineExecutableInfoKHR : public layout::PipelineExecutableInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(),
+ uint32_t executableIndex_ = 0 )
+ : layout::PipelineExecutableInfoKHR( pipeline_, executableIndex_ )
+ {}
+
+ PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs )
+ : layout::PipelineExecutableInfoKHR( rhs )
+ {}
+
+ PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs )
+ {
+ layout::PipelineExecutableInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ PipelineExecutableInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineExecutableInfoKHR & setPipeline( vk::Pipeline pipeline_ )
+ {
+ pipeline = pipeline_;
+ return *this;
+ }
+
+ PipelineExecutableInfoKHR & setExecutableIndex( uint32_t executableIndex_ )
+ {
+ executableIndex = executableIndex_;
+ return *this;
+ }
+
+ operator VkPipelineExecutableInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkPipelineExecutableInfoKHR*>( this );
+ }
+
+ operator VkPipelineExecutableInfoKHR &()
+ {
+ return *reinterpret_cast<VkPipelineExecutableInfoKHR*>( this );
+ }
+
+ bool operator==( PipelineExecutableInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( pipeline == rhs.pipeline )
+ && ( executableIndex == rhs.executableIndex );
+ }
+
+ bool operator!=( PipelineExecutableInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineExecutableInfoKHR::sType;
+ };
+ static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineExecutableInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineExecutableInternalRepresentationKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+ vk::Bool32 isText_ = 0,
+ size_t dataSize_ = 0,
+ void* pData_ = nullptr )
+ : name{}
+ , description{}
+ , isText( isText_ )
+ , dataSize( dataSize_ )
+ , pData( pData_ )
+ {
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+ }
+
+ PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
+ }
+
+ PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR;
+ void* pNext = nullptr;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ vk::Bool32 isText;
+ size_t dataSize;
+ void* pData;
+ };
+ static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineExecutableInternalRepresentationKHR : public layout::PipelineExecutableInternalRepresentationKHR
+ {
+ VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+ vk::Bool32 isText_ = 0,
+ size_t dataSize_ = 0,
+ void* pData_ = nullptr )
+ : layout::PipelineExecutableInternalRepresentationKHR( name_, description_, isText_, dataSize_, pData_ )
+ {}
+
+ PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+ : layout::PipelineExecutableInternalRepresentationKHR( rhs )
+ {}
+
+ PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs )
+ {
+ layout::PipelineExecutableInternalRepresentationKHR::operator=(rhs);
+ return *this;
+ }
+
+ PipelineExecutableInternalRepresentationKHR & setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineExecutableInternalRepresentationKHR & setName( std::array<char,VK_MAX_DESCRIPTION_SIZE> name_ )
+ {
+ memcpy( name, name_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+ return *this;
+ }
+
+ PipelineExecutableInternalRepresentationKHR & setDescription( std::array<char,VK_MAX_DESCRIPTION_SIZE> description_ )
+ {
+ memcpy( description, description_.data(), VK_MAX_DESCRIPTION_SIZE * sizeof( char ) );
+ return *this;
+ }
+
+ PipelineExecutableInternalRepresentationKHR & setIsText( vk::Bool32 isText_ )
+ {
+ isText = isText_;
+ return *this;
+ }
+
+ PipelineExecutableInternalRepresentationKHR & setDataSize( size_t dataSize_ )
+ {
+ dataSize = dataSize_;
+ return *this;
+ }
+
+ PipelineExecutableInternalRepresentationKHR & setPData( void* pData_ )
+ {
+ pData = pData_;
+ return *this;
+ }
+
+ operator VkPipelineExecutableInternalRepresentationKHR const&() const
+ {
+ return *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>( this );
+ }
+
+ operator VkPipelineExecutableInternalRepresentationKHR &()
+ {
+ return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( this );
+ }
+
+ bool operator==( PipelineExecutableInternalRepresentationKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+ && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+ && ( isText == rhs.isText )
+ && ( dataSize == rhs.dataSize )
+ && ( pData == rhs.pData );
+ }
+
+ bool operator!=( PipelineExecutableInternalRepresentationKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineExecutableInternalRepresentationKHR::sType;
+ };
+ static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineExecutableInternalRepresentationKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineExecutablePropertiesKHR
+ {
+ protected:
+ PipelineExecutablePropertiesKHR()
+ {}
+
+ PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this) = rhs;
+ }
+
+ PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR;
+ void* pNext = nullptr;
+ vk::ShaderStageFlags stages;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ uint32_t subgroupSize;
+ };
+ static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineExecutablePropertiesKHR : public layout::PipelineExecutablePropertiesKHR
+ {
+ PipelineExecutablePropertiesKHR()
+ : layout::PipelineExecutablePropertiesKHR()
+ {}
+
+ PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs )
+ : layout::PipelineExecutablePropertiesKHR( rhs )
+ {}
+
+ PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs )
+ {
+ layout::PipelineExecutablePropertiesKHR::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPipelineExecutablePropertiesKHR const&() const
+ {
+ return *reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>( this );
+ }
+
+ operator VkPipelineExecutablePropertiesKHR &()
+ {
+ return *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( this );
+ }
+
+ bool operator==( PipelineExecutablePropertiesKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( stages == rhs.stages )
+ && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+ && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 )
+ && ( subgroupSize == rhs.subgroupSize );
+ }
+
+ bool operator!=( PipelineExecutablePropertiesKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineExecutablePropertiesKHR::sType;
+ };
+ static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineExecutablePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
+
+ union PipelineExecutableStatisticValueKHR
+ {
+ operator VkPipelineExecutableStatisticValueKHR const&() const
+ {
+ return *reinterpret_cast<const VkPipelineExecutableStatisticValueKHR*>(this);
+ }
+
+ operator VkPipelineExecutableStatisticValueKHR &()
+ {
+ return *reinterpret_cast<VkPipelineExecutableStatisticValueKHR*>(this);
+ }
+
+#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+ vk::Bool32 b32;
+ int64_t i64;
+ uint64_t u64;
+ double f64;
+#else
+ VkBool32 b32;
+ int64_t i64;
+ uint64_t u64;
+ double f64;
+#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
+ };
+
+ namespace layout
+ {
+ struct PipelineExecutableStatisticKHR
+ {
+ protected:
+ PipelineExecutableStatisticKHR()
+ {}
+
+ PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this) = rhs;
+ }
+
+ PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
+ void* pNext = nullptr;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ vk::PipelineExecutableStatisticFormatKHR format;
+ vk::PipelineExecutableStatisticValueKHR value;
+ };
+ static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineExecutableStatisticKHR : public layout::PipelineExecutableStatisticKHR
+ {
+ PipelineExecutableStatisticKHR()
+ : layout::PipelineExecutableStatisticKHR()
+ {}
+
+ PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs )
+ : layout::PipelineExecutableStatisticKHR( rhs )
+ {}
+
+ PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs )
+ {
+ layout::PipelineExecutableStatisticKHR::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPipelineExecutableStatisticKHR const&() const
+ {
+ return *reinterpret_cast<const VkPipelineExecutableStatisticKHR*>( this );
+ }
+
+ operator VkPipelineExecutableStatisticKHR &()
+ {
+ return *reinterpret_cast<VkPipelineExecutableStatisticKHR*>( this );
+ }
+
+ private:
+ using layout::PipelineExecutableStatisticKHR::sType;
+ };
+ static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineExecutableStatisticKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() )
+ : pipeline( pipeline_ )
+ {}
+
+ PipelineInfoKHR( VkPipelineInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineInfoKHR*>(this) = rhs;
+ }
+
+ PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkPipelineInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineInfoKHR;
+ const void* pNext = nullptr;
+ vk::Pipeline pipeline;
+ };
+ static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineInfoKHR : public layout::PipelineInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() )
+ : layout::PipelineInfoKHR( pipeline_ )
+ {}
+
+ PipelineInfoKHR( VkPipelineInfoKHR const & rhs )
+ : layout::PipelineInfoKHR( rhs )
+ {}
+
+ PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs )
+ {
+ layout::PipelineInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ PipelineInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineInfoKHR & setPipeline( vk::Pipeline pipeline_ )
+ {
+ pipeline = pipeline_;
+ return *this;
+ }
+
+ operator VkPipelineInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkPipelineInfoKHR*>( this );
+ }
+
+ operator VkPipelineInfoKHR &()
+ {
+ return *reinterpret_cast<VkPipelineInfoKHR*>( this );
+ }
+
+ bool operator==( PipelineInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( pipeline == rhs.pipeline );
+ }
+
+ bool operator!=( PipelineInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineInfoKHR::sType;
+ };
+ static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct PushConstantRange
{
- PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(),
- uint32_t offset_ = 0,
- uint32_t size_ = 0 )
+ VULKAN_HPP_CONSTEXPR PushConstantRange( vk::ShaderStageFlags stageFlags_ = vk::ShaderStageFlags(),
+ uint32_t offset_ = 0,
+ uint32_t size_ = 0 )
: stageFlags( stageFlags_ )
, offset( offset_ )
, size( size_ )
@@ -42402,16 +55274,16 @@
PushConstantRange( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof( PushConstantRange ) );
+ *reinterpret_cast<VkPushConstantRange*>(this) = rhs;
}
PushConstantRange& operator=( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof( PushConstantRange ) );
+ *reinterpret_cast<VkPushConstantRange*>(this) = rhs;
return *this;
}
- PushConstantRange & setStageFlags( ShaderStageFlags stageFlags_ )
+ PushConstantRange & setStageFlags( vk::ShaderStageFlags stageFlags_ )
{
stageFlags = stageFlags_;
return *this;
@@ -42451,34 +55323,71 @@
return !operator==( rhs );
}
- ShaderStageFlags stageFlags;
+ public:
+ vk::ShaderStageFlags stageFlags;
uint32_t offset;
uint32_t size;
};
static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PushConstantRange>::value, "struct wrapper is not a standard layout!" );
- struct PipelineLayoutCreateInfo
+ namespace layout
{
- PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(),
- uint32_t setLayoutCount_ = 0,
- const DescriptorSetLayout* pSetLayouts_ = nullptr,
- uint32_t pushConstantRangeCount_ = 0,
- const PushConstantRange* pPushConstantRanges_ = nullptr )
- : flags( flags_ )
- , setLayoutCount( setLayoutCount_ )
- , pSetLayouts( pSetLayouts_ )
- , pushConstantRangeCount( pushConstantRangeCount_ )
- , pPushConstantRanges( pPushConstantRanges_ )
+ struct PipelineLayoutCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(),
+ uint32_t setLayoutCount_ = 0,
+ const vk::DescriptorSetLayout* pSetLayouts_ = nullptr,
+ uint32_t pushConstantRangeCount_ = 0,
+ const vk::PushConstantRange* pPushConstantRanges_ = nullptr )
+ : flags( flags_ )
+ , setLayoutCount( setLayoutCount_ )
+ , pSetLayouts( pSetLayouts_ )
+ , pushConstantRangeCount( pushConstantRangeCount_ )
+ , pPushConstantRanges( pPushConstantRanges_ )
+ {}
+
+ PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this) = rhs;
+ }
+
+ PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineLayoutCreateInfo;
+ const void* pNext = nullptr;
+ vk::PipelineLayoutCreateFlags flags;
+ uint32_t setLayoutCount;
+ const vk::DescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const vk::PushConstantRange* pPushConstantRanges;
+ };
+ static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineLayoutCreateInfo : public layout::PipelineLayoutCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(),
+ uint32_t setLayoutCount_ = 0,
+ const vk::DescriptorSetLayout* pSetLayouts_ = nullptr,
+ uint32_t pushConstantRangeCount_ = 0,
+ const vk::PushConstantRange* pPushConstantRanges_ = nullptr )
+ : layout::PipelineLayoutCreateInfo( flags_, setLayoutCount_, pSetLayouts_, pushConstantRangeCount_, pPushConstantRanges_ )
{}
PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
- }
+ : layout::PipelineLayoutCreateInfo( rhs )
+ {}
PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
+ layout::PipelineLayoutCreateInfo::operator=(rhs);
return *this;
}
@@ -42488,7 +55397,7 @@
return *this;
}
- PipelineLayoutCreateInfo & setFlags( PipelineLayoutCreateFlags flags_ )
+ PipelineLayoutCreateInfo & setFlags( vk::PipelineLayoutCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -42500,7 +55409,7 @@
return *this;
}
- PipelineLayoutCreateInfo & setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
+ PipelineLayoutCreateInfo & setPSetLayouts( const vk::DescriptorSetLayout* pSetLayouts_ )
{
pSetLayouts = pSetLayouts_;
return *this;
@@ -42512,7 +55421,7 @@
return *this;
}
- PipelineLayoutCreateInfo & setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
+ PipelineLayoutCreateInfo & setPPushConstantRanges( const vk::PushConstantRange* pPushConstantRanges_ )
{
pPushConstantRanges = pPushConstantRanges_;
return *this;
@@ -42545,36 +55454,60 @@
}
private:
- StructureType sType = StructureType::ePipelineLayoutCreateInfo;
-
- public:
- const void* pNext = nullptr;
- PipelineLayoutCreateFlags flags;
- uint32_t setLayoutCount;
- const DescriptorSetLayout* pSetLayouts;
- uint32_t pushConstantRangeCount;
- const PushConstantRange* pPushConstantRanges;
+ using layout::PipelineLayoutCreateInfo::sType;
};
static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct PipelineRasterizationConservativeStateCreateInfoEXT
+ namespace layout
{
- PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(),
- ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled,
- float extraPrimitiveOverestimationSize_ = 0 )
- : flags( flags_ )
- , conservativeRasterizationMode( conservativeRasterizationMode_ )
- , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+ struct PipelineRasterizationConservativeStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(),
+ vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled,
+ float extraPrimitiveOverestimationSize_ = 0 )
+ : flags( flags_ )
+ , conservativeRasterizationMode( conservativeRasterizationMode_ )
+ , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+ {}
+
+ PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags;
+ vk::ConservativeRasterizationModeEXT conservativeRasterizationMode;
+ float extraPrimitiveOverestimationSize;
+ };
+ static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRasterizationConservativeStateCreateInfoEXT : public layout::PipelineRasterizationConservativeStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(),
+ vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled,
+ float extraPrimitiveOverestimationSize_ = 0 )
+ : layout::PipelineRasterizationConservativeStateCreateInfoEXT( flags_, conservativeRasterizationMode_, extraPrimitiveOverestimationSize_ )
{}
PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
- }
+ : layout::PipelineRasterizationConservativeStateCreateInfoEXT( rhs )
+ {}
PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+ layout::PipelineRasterizationConservativeStateCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -42584,13 +55517,13 @@
return *this;
}
- PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
+ PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- PipelineRasterizationConservativeStateCreateInfoEXT & setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
+ PipelineRasterizationConservativeStateCreateInfoEXT & setConservativeRasterizationMode( vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
{
conservativeRasterizationMode = conservativeRasterizationMode_;
return *this;
@@ -42627,32 +55560,56 @@
}
private:
- StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- PipelineRasterizationConservativeStateCreateFlagsEXT flags;
- ConservativeRasterizationModeEXT conservativeRasterizationMode;
- float extraPrimitiveOverestimationSize;
+ using layout::PipelineRasterizationConservativeStateCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRasterizationConservativeStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineRasterizationDepthClipStateCreateInfoEXT
+ namespace layout
{
- PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = PipelineRasterizationDepthClipStateCreateFlagsEXT(),
- Bool32 depthClipEnable_ = 0 )
- : flags( flags_ )
- , depthClipEnable( depthClipEnable_ )
+ struct PipelineRasterizationDepthClipStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(),
+ vk::Bool32 depthClipEnable_ = 0 )
+ : flags( flags_ )
+ , depthClipEnable( depthClipEnable_ )
+ {}
+
+ PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags;
+ vk::Bool32 depthClipEnable;
+ };
+ static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRasterizationDepthClipStateCreateInfoEXT : public layout::PipelineRasterizationDepthClipStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(),
+ vk::Bool32 depthClipEnable_ = 0 )
+ : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( flags_, depthClipEnable_ )
{}
PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) );
- }
+ : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( rhs )
+ {}
PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) );
+ layout::PipelineRasterizationDepthClipStateCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -42662,13 +55619,13 @@
return *this;
}
- PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ )
+ PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
}
- PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( Bool32 depthClipEnable_ )
+ PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( vk::Bool32 depthClipEnable_ )
{
depthClipEnable = depthClipEnable_;
return *this;
@@ -42698,29 +55655,169 @@
}
private:
- StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- PipelineRasterizationDepthClipStateCreateFlagsEXT flags;
- Bool32 depthClipEnable;
+ using layout::PipelineRasterizationDepthClipStateCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRasterizationDepthClipStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineRasterizationStateRasterizationOrderAMD
+ namespace layout
{
- PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
- : rasterizationOrder( rasterizationOrder_ )
+ struct PipelineRasterizationLineStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault,
+ vk::Bool32 stippledLineEnable_ = 0,
+ uint32_t lineStippleFactor_ = 0,
+ uint16_t lineStipplePattern_ = 0 )
+ : lineRasterizationMode( lineRasterizationMode_ )
+ , stippledLineEnable( stippledLineEnable_ )
+ , lineStippleFactor( lineStippleFactor_ )
+ , lineStipplePattern( lineStipplePattern_ )
+ {}
+
+ PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::LineRasterizationModeEXT lineRasterizationMode;
+ vk::Bool32 stippledLineEnable;
+ uint32_t lineStippleFactor;
+ uint16_t lineStipplePattern;
+ };
+ static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRasterizationLineStateCreateInfoEXT : public layout::PipelineRasterizationLineStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault,
+ vk::Bool32 stippledLineEnable_ = 0,
+ uint32_t lineStippleFactor_ = 0,
+ uint16_t lineStipplePattern_ = 0 )
+ : layout::PipelineRasterizationLineStateCreateInfoEXT( lineRasterizationMode_, stippledLineEnable_, lineStippleFactor_, lineStipplePattern_ )
+ {}
+
+ PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+ : layout::PipelineRasterizationLineStateCreateInfoEXT( rhs )
+ {}
+
+ PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs )
+ {
+ layout::PipelineRasterizationLineStateCreateInfoEXT::operator=(rhs);
+ return *this;
+ }
+
+ PipelineRasterizationLineStateCreateInfoEXT & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineRasterizationLineStateCreateInfoEXT & setLineRasterizationMode( vk::LineRasterizationModeEXT lineRasterizationMode_ )
+ {
+ lineRasterizationMode = lineRasterizationMode_;
+ return *this;
+ }
+
+ PipelineRasterizationLineStateCreateInfoEXT & setStippledLineEnable( vk::Bool32 stippledLineEnable_ )
+ {
+ stippledLineEnable = stippledLineEnable_;
+ return *this;
+ }
+
+ PipelineRasterizationLineStateCreateInfoEXT & setLineStippleFactor( uint32_t lineStippleFactor_ )
+ {
+ lineStippleFactor = lineStippleFactor_;
+ return *this;
+ }
+
+ PipelineRasterizationLineStateCreateInfoEXT & setLineStipplePattern( uint16_t lineStipplePattern_ )
+ {
+ lineStipplePattern = lineStipplePattern_;
+ return *this;
+ }
+
+ operator VkPipelineRasterizationLineStateCreateInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>( this );
+ }
+
+ operator VkPipelineRasterizationLineStateCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>( this );
+ }
+
+ bool operator==( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( lineRasterizationMode == rhs.lineRasterizationMode )
+ && ( stippledLineEnable == rhs.stippledLineEnable )
+ && ( lineStippleFactor == rhs.lineStippleFactor )
+ && ( lineStipplePattern == rhs.lineStipplePattern );
+ }
+
+ bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineRasterizationLineStateCreateInfoEXT::sType;
+ };
+ static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRasterizationLineStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineRasterizationStateRasterizationOrderAMD
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict )
+ : rasterizationOrder( rasterizationOrder_ )
+ {}
+
+ PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
+ }
+
+ PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
+ const void* pNext = nullptr;
+ vk::RasterizationOrderAMD rasterizationOrder;
+ };
+ static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRasterizationStateRasterizationOrderAMD : public layout::PipelineRasterizationStateRasterizationOrderAMD
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict )
+ : layout::PipelineRasterizationStateRasterizationOrderAMD( rasterizationOrder_ )
{}
PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
- }
+ : layout::PipelineRasterizationStateRasterizationOrderAMD( rhs )
+ {}
PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
+ layout::PipelineRasterizationStateRasterizationOrderAMD::operator=(rhs);
return *this;
}
@@ -42730,7 +55827,7 @@
return *this;
}
- PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
+ PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( vk::RasterizationOrderAMD rasterizationOrder_ )
{
rasterizationOrder = rasterizationOrder_;
return *this;
@@ -42759,30 +55856,56 @@
}
private:
- StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
-
- public:
- const void* pNext = nullptr;
- RasterizationOrderAMD rasterizationOrder;
+ using layout::PipelineRasterizationStateRasterizationOrderAMD::sType;
};
static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRasterizationStateRasterizationOrderAMD>::value, "struct wrapper is not a standard layout!" );
- struct PipelineRasterizationStateStreamCreateInfoEXT
+ namespace layout
{
- PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = PipelineRasterizationStateStreamCreateFlagsEXT(),
- uint32_t rasterizationStream_ = 0 )
- : flags( flags_ )
- , rasterizationStream( rasterizationStream_ )
+ struct PipelineRasterizationStateStreamCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(),
+ uint32_t rasterizationStream_ = 0 )
+ : flags( flags_ )
+ , rasterizationStream( rasterizationStream_ )
+ {}
+
+ PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::PipelineRasterizationStateStreamCreateFlagsEXT flags;
+ uint32_t rasterizationStream;
+ };
+ static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRasterizationStateStreamCreateInfoEXT : public layout::PipelineRasterizationStateStreamCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(),
+ uint32_t rasterizationStream_ = 0 )
+ : layout::PipelineRasterizationStateStreamCreateInfoEXT( flags_, rasterizationStream_ )
{}
PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
- }
+ : layout::PipelineRasterizationStateStreamCreateInfoEXT( rhs )
+ {}
PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) );
+ layout::PipelineRasterizationStateStreamCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -42792,7 +55915,7 @@
return *this;
}
- PipelineRasterizationStateStreamCreateInfoEXT & setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
+ PipelineRasterizationStateStreamCreateInfoEXT & setFlags( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -42828,29 +55951,52 @@
}
private:
- StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- PipelineRasterizationStateStreamCreateFlagsEXT flags;
- uint32_t rasterizationStream;
+ using layout::PipelineRasterizationStateStreamCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRasterizationStateStreamCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineRepresentativeFragmentTestStateCreateInfoNV
+ namespace layout
{
- PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
- : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
+ struct PipelineRepresentativeFragmentTestStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 )
+ : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
+ {}
+
+ PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::Bool32 representativeFragmentTestEnable;
+ };
+ static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineRepresentativeFragmentTestStateCreateInfoNV : public layout::PipelineRepresentativeFragmentTestStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 )
+ : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( representativeFragmentTestEnable_ )
{}
PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
- }
+ : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( rhs )
+ {}
PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) );
+ layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -42860,7 +56006,7 @@
return *this;
}
- PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ )
+ PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable( vk::Bool32 representativeFragmentTestEnable_ )
{
representativeFragmentTestEnable = representativeFragmentTestEnable_;
return *this;
@@ -42889,30 +56035,56 @@
}
private:
- StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- Bool32 representativeFragmentTestEnable;
+ using layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineRepresentativeFragmentTestStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineSampleLocationsStateCreateInfoEXT
+ namespace layout
{
- PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0,
- SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
- : sampleLocationsEnable( sampleLocationsEnable_ )
- , sampleLocationsInfo( sampleLocationsInfo_ )
+ struct PipelineSampleLocationsStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0,
+ vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
+ : sampleLocationsEnable( sampleLocationsEnable_ )
+ , sampleLocationsInfo( sampleLocationsInfo_ )
+ {}
+
+ PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::Bool32 sampleLocationsEnable;
+ vk::SampleLocationsInfoEXT sampleLocationsInfo;
+ };
+ static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineSampleLocationsStateCreateInfoEXT : public layout::PipelineSampleLocationsStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0,
+ vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
+ : layout::PipelineSampleLocationsStateCreateInfoEXT( sampleLocationsEnable_, sampleLocationsInfo_ )
{}
PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
- }
+ : layout::PipelineSampleLocationsStateCreateInfoEXT( rhs )
+ {}
PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
+ layout::PipelineSampleLocationsStateCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -42922,13 +56094,13 @@
return *this;
}
- PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
+ PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( vk::Bool32 sampleLocationsEnable_ )
{
sampleLocationsEnable = sampleLocationsEnable_;
return *this;
}
- PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( vk::SampleLocationsInfoEXT sampleLocationsInfo_ )
{
sampleLocationsInfo = sampleLocationsInfo_;
return *this;
@@ -42958,29 +56130,123 @@
}
private:
- StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- Bool32 sampleLocationsEnable;
- SampleLocationsInfoEXT sampleLocationsInfo;
+ using layout::PipelineSampleLocationsStateCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineSampleLocationsStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineTessellationDomainOriginStateCreateInfo
+ namespace layout
{
- PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft )
- : domainOrigin( domainOrigin_ )
+ struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
+ {
+ protected:
+ PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT()
+ {}
+
+ PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+ void* pNext = nullptr;
+ uint32_t requiredSubgroupSize;
+ };
+ static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : public layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
+ {
+ PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT()
+ : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT()
+ {}
+
+ PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs )
+ : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( rhs )
+ {}
+
+ PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs )
+ {
+ layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::operator=(rhs);
+ return *this;
+ }
+
+ operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const&() const
+ {
+ return *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this );
+ }
+
+ operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT &()
+ {
+ return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this );
+ }
+
+ bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( requiredSubgroupSize == rhs.requiredSubgroupSize );
+ }
+
+ bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::sType;
+ };
+ static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct PipelineTessellationDomainOriginStateCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft )
+ : domainOrigin( domainOrigin_ )
+ {}
+
+ PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
+ }
+
+ PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
+ const void* pNext = nullptr;
+ vk::TessellationDomainOrigin domainOrigin;
+ };
+ static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineTessellationDomainOriginStateCreateInfo : public layout::PipelineTessellationDomainOriginStateCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft )
+ : layout::PipelineTessellationDomainOriginStateCreateInfo( domainOrigin_ )
{}
PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
- }
+ : layout::PipelineTessellationDomainOriginStateCreateInfo( rhs )
+ {}
PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfo ) );
+ layout::PipelineTessellationDomainOriginStateCreateInfo::operator=(rhs);
return *this;
}
@@ -42990,7 +56256,7 @@
return *this;
}
- PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( TessellationDomainOrigin domainOrigin_ )
+ PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( vk::TessellationDomainOrigin domainOrigin_ )
{
domainOrigin = domainOrigin_;
return *this;
@@ -43019,30 +56285,27 @@
}
private:
- StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo;
-
- public:
- const void* pNext = nullptr;
- TessellationDomainOrigin domainOrigin;
+ using layout::PipelineTessellationDomainOriginStateCreateInfo::sType;
};
static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineTessellationDomainOriginStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct VertexInputBindingDivisorDescriptionEXT
{
- VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0,
- uint32_t divisor_ = 0 )
+ VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = 0,
+ uint32_t divisor_ = 0 )
: binding( binding_ )
, divisor( divisor_ )
{}
VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
+ *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this) = rhs;
}
VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
+ *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this) = rhs;
return *this;
}
@@ -43079,27 +56342,58 @@
return !operator==( rhs );
}
+ public:
uint32_t binding;
uint32_t divisor;
};
static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<VertexInputBindingDivisorDescriptionEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineVertexInputDivisorStateCreateInfoEXT
+ namespace layout
{
- PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
- const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
- : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
- , pVertexBindingDivisors( pVertexBindingDivisors_ )
+ struct PipelineVertexInputDivisorStateCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
+ const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
+ : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
+ , pVertexBindingDivisors( pVertexBindingDivisors_ )
+ {}
+
+ PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
+ }
+
+ PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
+ const void* pNext = nullptr;
+ uint32_t vertexBindingDivisorCount;
+ const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
+ };
+ static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineVertexInputDivisorStateCreateInfoEXT : public layout::PipelineVertexInputDivisorStateCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0,
+ const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
+ : layout::PipelineVertexInputDivisorStateCreateInfoEXT( vertexBindingDivisorCount_, pVertexBindingDivisors_ )
{}
PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
- }
+ : layout::PipelineVertexInputDivisorStateCreateInfoEXT( rhs )
+ {}
PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) );
+ layout::PipelineVertexInputDivisorStateCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -43115,7 +56409,7 @@
return *this;
}
- PipelineVertexInputDivisorStateCreateInfoEXT & setPVertexBindingDivisors( const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ )
+ PipelineVertexInputDivisorStateCreateInfoEXT & setPVertexBindingDivisors( const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ )
{
pVertexBindingDivisors = pVertexBindingDivisors_;
return *this;
@@ -43145,33 +56439,60 @@
}
private:
- StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t vertexBindingDivisorCount;
- const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
+ using layout::PipelineVertexInputDivisorStateCreateInfoEXT::sType;
};
static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineVertexInputDivisorStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+ namespace layout
{
- PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault,
- uint32_t customSampleOrderCount_ = 0,
- const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
- : sampleOrderType( sampleOrderType_ )
- , customSampleOrderCount( customSampleOrderCount_ )
- , pCustomSampleOrders( pCustomSampleOrders_ )
+ struct PipelineViewportCoarseSampleOrderStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault,
+ uint32_t customSampleOrderCount_ = 0,
+ const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+ : sampleOrderType( sampleOrderType_ )
+ , customSampleOrderCount( customSampleOrderCount_ )
+ , pCustomSampleOrders( pCustomSampleOrders_ )
+ {}
+
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::CoarseSampleOrderTypeNV sampleOrderType;
+ uint32_t customSampleOrderCount;
+ const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders;
+ };
+ static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineViewportCoarseSampleOrderStateCreateInfoNV : public layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault,
+ uint32_t customSampleOrderCount_ = 0,
+ const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
+ : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( sampleOrderType_, customSampleOrderCount_, pCustomSampleOrders_ )
{}
PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
- }
+ : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( rhs )
+ {}
PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) );
+ layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -43181,7 +56502,7 @@
return *this;
}
- PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ )
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( vk::CoarseSampleOrderTypeNV sampleOrderType_ )
{
sampleOrderType = sampleOrderType_;
return *this;
@@ -43193,7 +56514,7 @@
return *this;
}
- PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders( const CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
+ PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders( const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ )
{
pCustomSampleOrders = pCustomSampleOrders_;
return *this;
@@ -43224,32 +56545,56 @@
}
private:
- StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- CoarseSampleOrderTypeNV sampleOrderType;
- uint32_t customSampleOrderCount;
- const CoarseSampleOrderCustomNV* pCustomSampleOrders;
+ using layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineViewportCoarseSampleOrderStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineViewportExclusiveScissorStateCreateInfoNV
+ namespace layout
{
- PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
- const Rect2D* pExclusiveScissors_ = nullptr )
- : exclusiveScissorCount( exclusiveScissorCount_ )
- , pExclusiveScissors( pExclusiveScissors_ )
+ struct PipelineViewportExclusiveScissorStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
+ const vk::Rect2D* pExclusiveScissors_ = nullptr )
+ : exclusiveScissorCount( exclusiveScissorCount_ )
+ , pExclusiveScissors( pExclusiveScissors_ )
+ {}
+
+ PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
+ const void* pNext = nullptr;
+ uint32_t exclusiveScissorCount;
+ const vk::Rect2D* pExclusiveScissors;
+ };
+ static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineViewportExclusiveScissorStateCreateInfoNV : public layout::PipelineViewportExclusiveScissorStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0,
+ const vk::Rect2D* pExclusiveScissors_ = nullptr )
+ : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( exclusiveScissorCount_, pExclusiveScissors_ )
{}
PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
- }
+ : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( rhs )
+ {}
PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) );
+ layout::PipelineViewportExclusiveScissorStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -43265,7 +56610,7 @@
return *this;
}
- PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const Rect2D* pExclusiveScissors_ )
+ PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const vk::Rect2D* pExclusiveScissors_ )
{
pExclusiveScissors = pExclusiveScissors_;
return *this;
@@ -43295,31 +56640,27 @@
}
private:
- StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- uint32_t exclusiveScissorCount;
- const Rect2D* pExclusiveScissors;
+ using layout::PipelineViewportExclusiveScissorStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineViewportExclusiveScissorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
struct ShadingRatePaletteNV
{
- ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
- const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
+ VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
+ const vk::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
: shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
, pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
{}
ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
+ *reinterpret_cast<VkShadingRatePaletteNV*>(this) = rhs;
}
ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
+ *reinterpret_cast<VkShadingRatePaletteNV*>(this) = rhs;
return *this;
}
@@ -43329,7 +56670,7 @@
return *this;
}
- ShadingRatePaletteNV & setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
+ ShadingRatePaletteNV & setPShadingRatePaletteEntries( const vk::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ )
{
pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
return *this;
@@ -43356,29 +56697,62 @@
return !operator==( rhs );
}
+ public:
uint32_t shadingRatePaletteEntryCount;
- const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
+ const vk::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries;
};
static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ShadingRatePaletteNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineViewportShadingRateImageStateCreateInfoNV
+ namespace layout
{
- PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = 0,
- uint32_t viewportCount_ = 0,
- const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
- : shadingRateImageEnable( shadingRateImageEnable_ )
- , viewportCount( viewportCount_ )
- , pShadingRatePalettes( pShadingRatePalettes_ )
+ struct PipelineViewportShadingRateImageStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0,
+ uint32_t viewportCount_ = 0,
+ const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+ : shadingRateImageEnable( shadingRateImageEnable_ )
+ , viewportCount( viewportCount_ )
+ , pShadingRatePalettes( pShadingRatePalettes_ )
+ {}
+
+ PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::Bool32 shadingRateImageEnable;
+ uint32_t viewportCount;
+ const vk::ShadingRatePaletteNV* pShadingRatePalettes;
+ };
+ static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineViewportShadingRateImageStateCreateInfoNV : public layout::PipelineViewportShadingRateImageStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0,
+ uint32_t viewportCount_ = 0,
+ const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
+ : layout::PipelineViewportShadingRateImageStateCreateInfoNV( shadingRateImageEnable_, viewportCount_, pShadingRatePalettes_ )
{}
PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
- }
+ : layout::PipelineViewportShadingRateImageStateCreateInfoNV( rhs )
+ {}
PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) );
+ layout::PipelineViewportShadingRateImageStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -43388,7 +56762,7 @@
return *this;
}
- PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( Bool32 shadingRateImageEnable_ )
+ PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( vk::Bool32 shadingRateImageEnable_ )
{
shadingRateImageEnable = shadingRateImageEnable_;
return *this;
@@ -43400,7 +56774,7 @@
return *this;
}
- PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const ShadingRatePaletteNV* pShadingRatePalettes_ )
+ PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const vk::ShadingRatePaletteNV* pShadingRatePalettes_ )
{
pShadingRatePalettes = pShadingRatePalettes_;
return *this;
@@ -43431,22 +56805,17 @@
}
private:
- StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- Bool32 shadingRateImageEnable;
- uint32_t viewportCount;
- const ShadingRatePaletteNV* pShadingRatePalettes;
+ using layout::PipelineViewportShadingRateImageStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineViewportShadingRateImageStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
struct ViewportSwizzleNV
{
- ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX,
- ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX,
- ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX,
- ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX )
+ VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( vk::ViewportCoordinateSwizzleNV x_ = vk::ViewportCoordinateSwizzleNV::ePositiveX,
+ vk::ViewportCoordinateSwizzleNV y_ = vk::ViewportCoordinateSwizzleNV::ePositiveX,
+ vk::ViewportCoordinateSwizzleNV z_ = vk::ViewportCoordinateSwizzleNV::ePositiveX,
+ vk::ViewportCoordinateSwizzleNV w_ = vk::ViewportCoordinateSwizzleNV::ePositiveX )
: x( x_ )
, y( y_ )
, z( z_ )
@@ -43455,34 +56824,34 @@
ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
+ *reinterpret_cast<VkViewportSwizzleNV*>(this) = rhs;
}
ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
+ *reinterpret_cast<VkViewportSwizzleNV*>(this) = rhs;
return *this;
}
- ViewportSwizzleNV & setX( ViewportCoordinateSwizzleNV x_ )
+ ViewportSwizzleNV & setX( vk::ViewportCoordinateSwizzleNV x_ )
{
x = x_;
return *this;
}
- ViewportSwizzleNV & setY( ViewportCoordinateSwizzleNV y_ )
+ ViewportSwizzleNV & setY( vk::ViewportCoordinateSwizzleNV y_ )
{
y = y_;
return *this;
}
- ViewportSwizzleNV & setZ( ViewportCoordinateSwizzleNV z_ )
+ ViewportSwizzleNV & setZ( vk::ViewportCoordinateSwizzleNV z_ )
{
z = z_;
return *this;
}
- ViewportSwizzleNV & setW( ViewportCoordinateSwizzleNV w_ )
+ ViewportSwizzleNV & setW( vk::ViewportCoordinateSwizzleNV w_ )
{
w = w_;
return *this;
@@ -43511,31 +56880,64 @@
return !operator==( rhs );
}
- ViewportCoordinateSwizzleNV x;
- ViewportCoordinateSwizzleNV y;
- ViewportCoordinateSwizzleNV z;
- ViewportCoordinateSwizzleNV w;
+ public:
+ vk::ViewportCoordinateSwizzleNV x;
+ vk::ViewportCoordinateSwizzleNV y;
+ vk::ViewportCoordinateSwizzleNV z;
+ vk::ViewportCoordinateSwizzleNV w;
};
static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ViewportSwizzleNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineViewportSwizzleStateCreateInfoNV
+ namespace layout
{
- PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(),
- uint32_t viewportCount_ = 0,
- const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
- : flags( flags_ )
- , viewportCount( viewportCount_ )
- , pViewportSwizzles( pViewportSwizzles_ )
+ struct PipelineViewportSwizzleStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(),
+ uint32_t viewportCount_ = 0,
+ const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
+ : flags( flags_ )
+ , viewportCount( viewportCount_ )
+ , pViewportSwizzles( pViewportSwizzles_ )
+ {}
+
+ PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::PipelineViewportSwizzleStateCreateFlagsNV flags;
+ uint32_t viewportCount;
+ const vk::ViewportSwizzleNV* pViewportSwizzles;
+ };
+ static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineViewportSwizzleStateCreateInfoNV : public layout::PipelineViewportSwizzleStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(),
+ uint32_t viewportCount_ = 0,
+ const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
+ : layout::PipelineViewportSwizzleStateCreateInfoNV( flags_, viewportCount_, pViewportSwizzles_ )
{}
PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
- }
+ : layout::PipelineViewportSwizzleStateCreateInfoNV( rhs )
+ {}
PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
+ layout::PipelineViewportSwizzleStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -43545,7 +56947,7 @@
return *this;
}
- PipelineViewportSwizzleStateCreateInfoNV & setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
+ PipelineViewportSwizzleStateCreateInfoNV & setFlags( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ )
{
flags = flags_;
return *this;
@@ -43557,7 +56959,7 @@
return *this;
}
- PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
+ PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const vk::ViewportSwizzleNV* pViewportSwizzles_ )
{
pViewportSwizzles = pViewportSwizzles_;
return *this;
@@ -43588,32 +56990,27 @@
}
private:
- StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- PipelineViewportSwizzleStateCreateFlagsNV flags;
- uint32_t viewportCount;
- const ViewportSwizzleNV* pViewportSwizzles;
+ using layout::PipelineViewportSwizzleStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineViewportSwizzleStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
struct ViewportWScalingNV
{
- ViewportWScalingNV( float xcoeff_ = 0,
- float ycoeff_ = 0 )
+ VULKAN_HPP_CONSTEXPR ViewportWScalingNV( float xcoeff_ = 0,
+ float ycoeff_ = 0 )
: xcoeff( xcoeff_ )
, ycoeff( ycoeff_ )
{}
ViewportWScalingNV( VkViewportWScalingNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
+ *reinterpret_cast<VkViewportWScalingNV*>(this) = rhs;
}
ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
{
- memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
+ *reinterpret_cast<VkViewportWScalingNV*>(this) = rhs;
return *this;
}
@@ -43650,29 +57047,62 @@
return !operator==( rhs );
}
+ public:
float xcoeff;
float ycoeff;
};
static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ViewportWScalingNV>::value, "struct wrapper is not a standard layout!" );
- struct PipelineViewportWScalingStateCreateInfoNV
+ namespace layout
{
- PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0,
- uint32_t viewportCount_ = 0,
- const ViewportWScalingNV* pViewportWScalings_ = nullptr )
- : viewportWScalingEnable( viewportWScalingEnable_ )
- , viewportCount( viewportCount_ )
- , pViewportWScalings( pViewportWScalings_ )
+ struct PipelineViewportWScalingStateCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0,
+ uint32_t viewportCount_ = 0,
+ const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr )
+ : viewportWScalingEnable( viewportWScalingEnable_ )
+ , viewportCount( viewportCount_ )
+ , pViewportWScalings( pViewportWScalings_ )
+ {}
+
+ PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
+ }
+
+ PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::Bool32 viewportWScalingEnable;
+ uint32_t viewportCount;
+ const vk::ViewportWScalingNV* pViewportWScalings;
+ };
+ static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PipelineViewportWScalingStateCreateInfoNV : public layout::PipelineViewportWScalingStateCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0,
+ uint32_t viewportCount_ = 0,
+ const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr )
+ : layout::PipelineViewportWScalingStateCreateInfoNV( viewportWScalingEnable_, viewportCount_, pViewportWScalings_ )
{}
PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
- }
+ : layout::PipelineViewportWScalingStateCreateInfoNV( rhs )
+ {}
PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
+ layout::PipelineViewportWScalingStateCreateInfoNV::operator=(rhs);
return *this;
}
@@ -43682,7 +57112,7 @@
return *this;
}
- PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( Bool32 viewportWScalingEnable_ )
+ PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( vk::Bool32 viewportWScalingEnable_ )
{
viewportWScalingEnable = viewportWScalingEnable_;
return *this;
@@ -43694,7 +57124,7 @@
return *this;
}
- PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ )
+ PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const vk::ViewportWScalingNV* pViewportWScalings_ )
{
pViewportWScalings = pViewportWScalings_;
return *this;
@@ -43725,31 +57155,54 @@
}
private:
- StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- Bool32 viewportWScalingEnable;
- uint32_t viewportCount;
- const ViewportWScalingNV* pViewportWScalings;
+ using layout::PipelineViewportWScalingStateCreateInfoNV::sType;
};
static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PipelineViewportWScalingStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_GGP
- struct PresentFrameTokenGGP
+
+ namespace layout
{
- PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 )
- : frameToken( frameToken_ )
+ struct PresentFrameTokenGGP
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 )
+ : frameToken( frameToken_ )
+ {}
+
+ PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs )
+ {
+ *reinterpret_cast<VkPresentFrameTokenGGP*>(this) = rhs;
+ }
+
+ PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs )
+ {
+ *reinterpret_cast<VkPresentFrameTokenGGP*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePresentFrameTokenGGP;
+ const void* pNext = nullptr;
+ GgpFrameToken frameToken;
+ };
+ static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PresentFrameTokenGGP : public layout::PresentFrameTokenGGP
+ {
+ VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 )
+ : layout::PresentFrameTokenGGP( frameToken_ )
{}
PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs )
- {
- memcpy( this, &rhs, sizeof( PresentFrameTokenGGP ) );
- }
+ : layout::PresentFrameTokenGGP( rhs )
+ {}
PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentFrameTokenGGP ) );
+ layout::PresentFrameTokenGGP::operator=(rhs);
return *this;
}
@@ -43788,39 +57241,73 @@
}
private:
- StructureType sType = StructureType::ePresentFrameTokenGGP;
-
- public:
- const void* pNext = nullptr;
- GgpFrameToken frameToken;
+ using layout::PresentFrameTokenGGP::sType;
};
static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PresentFrameTokenGGP>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_GGP*/
- struct PresentInfoKHR
+ namespace layout
{
- 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 )
- : waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , swapchainCount( swapchainCount_ )
- , pSwapchains( pSwapchains_ )
- , pImageIndices( pImageIndices_ )
- , pResults( pResults_ )
+ struct PresentInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
+ const vk::Semaphore* pWaitSemaphores_ = nullptr,
+ uint32_t swapchainCount_ = 0,
+ const vk::SwapchainKHR* pSwapchains_ = nullptr,
+ const uint32_t* pImageIndices_ = nullptr,
+ vk::Result* pResults_ = nullptr )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , swapchainCount( swapchainCount_ )
+ , pSwapchains( pSwapchains_ )
+ , pImageIndices( pImageIndices_ )
+ , pResults( pResults_ )
+ {}
+
+ PresentInfoKHR( VkPresentInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkPresentInfoKHR*>(this) = rhs;
+ }
+
+ PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkPresentInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePresentInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreCount;
+ const vk::Semaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ const vk::SwapchainKHR* pSwapchains;
+ const uint32_t* pImageIndices;
+ vk::Result* pResults;
+ };
+ static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PresentInfoKHR : public layout::PresentInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
+ const vk::Semaphore* pWaitSemaphores_ = nullptr,
+ uint32_t swapchainCount_ = 0,
+ const vk::SwapchainKHR* pSwapchains_ = nullptr,
+ const uint32_t* pImageIndices_ = nullptr,
+ vk::Result* pResults_ = nullptr )
+ : layout::PresentInfoKHR( waitSemaphoreCount_, pWaitSemaphores_, swapchainCount_, pSwapchains_, pImageIndices_, pResults_ )
{}
PresentInfoKHR( VkPresentInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
- }
+ : layout::PresentInfoKHR( rhs )
+ {}
PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
+ layout::PresentInfoKHR::operator=(rhs);
return *this;
}
@@ -43836,7 +57323,7 @@
return *this;
}
- PresentInfoKHR & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ PresentInfoKHR & setPWaitSemaphores( const vk::Semaphore* pWaitSemaphores_ )
{
pWaitSemaphores = pWaitSemaphores_;
return *this;
@@ -43848,7 +57335,7 @@
return *this;
}
- PresentInfoKHR & setPSwapchains( const SwapchainKHR* pSwapchains_ )
+ PresentInfoKHR & setPSwapchains( const vk::SwapchainKHR* pSwapchains_ )
{
pSwapchains = pSwapchains_;
return *this;
@@ -43860,7 +57347,7 @@
return *this;
}
- PresentInfoKHR & setPResults( Result* pResults_ )
+ PresentInfoKHR & setPResults( vk::Result* pResults_ )
{
pResults = pResults_;
return *this;
@@ -43894,24 +57381,16 @@
}
private:
- StructureType sType = StructureType::ePresentInfoKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- uint32_t swapchainCount;
- const SwapchainKHR* pSwapchains;
- const uint32_t* pImageIndices;
- Result* pResults;
+ using layout::PresentInfoKHR::sType;
};
static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct RectLayerKHR
{
- RectLayerKHR( Offset2D offset_ = Offset2D(),
- Extent2D extent_ = Extent2D(),
- uint32_t layer_ = 0 )
+ VULKAN_HPP_CONSTEXPR RectLayerKHR( vk::Offset2D offset_ = vk::Offset2D(),
+ vk::Extent2D extent_ = vk::Extent2D(),
+ uint32_t layer_ = 0 )
: offset( offset_ )
, extent( extent_ )
, layer( layer_ )
@@ -43926,22 +57405,22 @@
RectLayerKHR( VkRectLayerKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( RectLayerKHR ) );
+ *reinterpret_cast<VkRectLayerKHR*>(this) = rhs;
}
RectLayerKHR& operator=( VkRectLayerKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( RectLayerKHR ) );
+ *reinterpret_cast<VkRectLayerKHR*>(this) = rhs;
return *this;
}
- RectLayerKHR & setOffset( Offset2D offset_ )
+ RectLayerKHR & setOffset( vk::Offset2D offset_ )
{
offset = offset_;
return *this;
}
- RectLayerKHR & setExtent( Extent2D extent_ )
+ RectLayerKHR & setExtent( vk::Extent2D extent_ )
{
extent = extent_;
return *this;
@@ -43975,28 +57454,30 @@
return !operator==( rhs );
}
- Offset2D offset;
- Extent2D extent;
+ public:
+ vk::Offset2D offset;
+ vk::Extent2D extent;
uint32_t layer;
};
static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RectLayerKHR>::value, "struct wrapper is not a standard layout!" );
struct PresentRegionKHR
{
- PresentRegionKHR( uint32_t rectangleCount_ = 0,
- const RectLayerKHR* pRectangles_ = nullptr )
+ VULKAN_HPP_CONSTEXPR PresentRegionKHR( uint32_t rectangleCount_ = 0,
+ const vk::RectLayerKHR* pRectangles_ = nullptr )
: rectangleCount( rectangleCount_ )
, pRectangles( pRectangles_ )
{}
PresentRegionKHR( VkPresentRegionKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
+ *reinterpret_cast<VkPresentRegionKHR*>(this) = rhs;
}
PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
+ *reinterpret_cast<VkPresentRegionKHR*>(this) = rhs;
return *this;
}
@@ -44006,7 +57487,7 @@
return *this;
}
- PresentRegionKHR & setPRectangles( const RectLayerKHR* pRectangles_ )
+ PresentRegionKHR & setPRectangles( const vk::RectLayerKHR* pRectangles_ )
{
pRectangles = pRectangles_;
return *this;
@@ -44033,27 +57514,58 @@
return !operator==( rhs );
}
+ public:
uint32_t rectangleCount;
- const RectLayerKHR* pRectangles;
+ const vk::RectLayerKHR* pRectangles;
};
static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PresentRegionKHR>::value, "struct wrapper is not a standard layout!" );
- struct PresentRegionsKHR
+ namespace layout
{
- PresentRegionsKHR( uint32_t swapchainCount_ = 0,
- const PresentRegionKHR* pRegions_ = nullptr )
- : swapchainCount( swapchainCount_ )
- , pRegions( pRegions_ )
+ struct PresentRegionsKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0,
+ const vk::PresentRegionKHR* pRegions_ = nullptr )
+ : swapchainCount( swapchainCount_ )
+ , pRegions( pRegions_ )
+ {}
+
+ PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
+ {
+ *reinterpret_cast<VkPresentRegionsKHR*>(this) = rhs;
+ }
+
+ PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
+ {
+ *reinterpret_cast<VkPresentRegionsKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePresentRegionsKHR;
+ const void* pNext = nullptr;
+ uint32_t swapchainCount;
+ const vk::PresentRegionKHR* pRegions;
+ };
+ static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PresentRegionsKHR : public layout::PresentRegionsKHR
+ {
+ VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0,
+ const vk::PresentRegionKHR* pRegions_ = nullptr )
+ : layout::PresentRegionsKHR( swapchainCount_, pRegions_ )
{}
PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
- }
+ : layout::PresentRegionsKHR( rhs )
+ {}
PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
+ layout::PresentRegionsKHR::operator=(rhs);
return *this;
}
@@ -44069,7 +57581,7 @@
return *this;
}
- PresentRegionsKHR & setPRegions( const PresentRegionKHR* pRegions_ )
+ PresentRegionsKHR & setPRegions( const vk::PresentRegionKHR* pRegions_ )
{
pRegions = pRegions_;
return *this;
@@ -44099,31 +57611,27 @@
}
private:
- StructureType sType = StructureType::ePresentRegionsKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t swapchainCount;
- const PresentRegionKHR* pRegions;
+ using layout::PresentRegionsKHR::sType;
};
static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PresentRegionsKHR>::value, "struct wrapper is not a standard layout!" );
struct PresentTimeGOOGLE
{
- PresentTimeGOOGLE( uint32_t presentID_ = 0,
- uint64_t desiredPresentTime_ = 0 )
+ VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( uint32_t presentID_ = 0,
+ uint64_t desiredPresentTime_ = 0 )
: presentID( presentID_ )
, desiredPresentTime( desiredPresentTime_ )
{}
PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
+ *reinterpret_cast<VkPresentTimeGOOGLE*>(this) = rhs;
}
PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
+ *reinterpret_cast<VkPresentTimeGOOGLE*>(this) = rhs;
return *this;
}
@@ -44160,27 +57668,58 @@
return !operator==( rhs );
}
+ public:
uint32_t presentID;
uint64_t desiredPresentTime;
};
static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PresentTimeGOOGLE>::value, "struct wrapper is not a standard layout!" );
- struct PresentTimesInfoGOOGLE
+ namespace layout
{
- PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
- const PresentTimeGOOGLE* pTimes_ = nullptr )
- : swapchainCount( swapchainCount_ )
- , pTimes( pTimes_ )
+ struct PresentTimesInfoGOOGLE
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
+ const vk::PresentTimeGOOGLE* pTimes_ = nullptr )
+ : swapchainCount( swapchainCount_ )
+ , pTimes( pTimes_ )
+ {}
+
+ PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
+ {
+ *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this) = rhs;
+ }
+
+ PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
+ {
+ *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
+ const void* pNext = nullptr;
+ uint32_t swapchainCount;
+ const vk::PresentTimeGOOGLE* pTimes;
+ };
+ static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "layout struct and wrapper have different size!" );
+ }
+
+ struct PresentTimesInfoGOOGLE : public layout::PresentTimesInfoGOOGLE
+ {
+ VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
+ const vk::PresentTimeGOOGLE* pTimes_ = nullptr )
+ : layout::PresentTimesInfoGOOGLE( swapchainCount_, pTimes_ )
{}
PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
- {
- memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
- }
+ : layout::PresentTimesInfoGOOGLE( rhs )
+ {}
PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
+ layout::PresentTimesInfoGOOGLE::operator=(rhs);
return *this;
}
@@ -44196,7 +57735,7 @@
return *this;
}
- PresentTimesInfoGOOGLE & setPTimes( const PresentTimeGOOGLE* pTimes_ )
+ PresentTimesInfoGOOGLE & setPTimes( const vk::PresentTimeGOOGLE* pTimes_ )
{
pTimes = pTimes_;
return *this;
@@ -44226,29 +57765,52 @@
}
private:
- StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
-
- public:
- const void* pNext = nullptr;
- uint32_t swapchainCount;
- const PresentTimeGOOGLE* pTimes;
+ using layout::PresentTimesInfoGOOGLE::sType;
};
static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<PresentTimesInfoGOOGLE>::value, "struct wrapper is not a standard layout!" );
- struct ProtectedSubmitInfo
+ namespace layout
{
- ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 )
- : protectedSubmit( protectedSubmit_ )
+ struct ProtectedSubmitInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 )
+ : protectedSubmit( protectedSubmit_ )
+ {}
+
+ ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs )
+ {
+ *reinterpret_cast<VkProtectedSubmitInfo*>(this) = rhs;
+ }
+
+ ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs )
+ {
+ *reinterpret_cast<VkProtectedSubmitInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eProtectedSubmitInfo;
+ const void* pNext = nullptr;
+ vk::Bool32 protectedSubmit;
+ };
+ static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ProtectedSubmitInfo : public layout::ProtectedSubmitInfo
+ {
+ VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 )
+ : layout::ProtectedSubmitInfo( protectedSubmit_ )
{}
ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
- }
+ : layout::ProtectedSubmitInfo( rhs )
+ {}
ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
+ layout::ProtectedSubmitInfo::operator=(rhs);
return *this;
}
@@ -44258,7 +57820,7 @@
return *this;
}
- ProtectedSubmitInfo & setProtectedSubmit( Bool32 protectedSubmit_ )
+ ProtectedSubmitInfo & setProtectedSubmit( vk::Bool32 protectedSubmit_ )
{
protectedSubmit = protectedSubmit_;
return *this;
@@ -44287,34 +57849,64 @@
}
private:
- StructureType sType = StructureType::eProtectedSubmitInfo;
-
- public:
- const void* pNext = nullptr;
- Bool32 protectedSubmit;
+ using layout::ProtectedSubmitInfo::sType;
};
static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ProtectedSubmitInfo>::value, "struct wrapper is not a standard layout!" );
- struct QueryPoolCreateInfo
+ namespace layout
{
- QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(),
- QueryType queryType_ = QueryType::eOcclusion,
- uint32_t queryCount_ = 0,
- QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : flags( flags_ )
- , queryType( queryType_ )
- , queryCount( queryCount_ )
- , pipelineStatistics( pipelineStatistics_ )
+ struct QueryPoolCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(),
+ vk::QueryType queryType_ = vk::QueryType::eOcclusion,
+ uint32_t queryCount_ = 0,
+ vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+ : flags( flags_ )
+ , queryType( queryType_ )
+ , queryCount( queryCount_ )
+ , pipelineStatistics( pipelineStatistics_ )
+ {}
+
+ QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkQueryPoolCreateInfo*>(this) = rhs;
+ }
+
+ QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkQueryPoolCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eQueryPoolCreateInfo;
+ const void* pNext = nullptr;
+ vk::QueryPoolCreateFlags flags;
+ vk::QueryType queryType;
+ uint32_t queryCount;
+ vk::QueryPipelineStatisticFlags pipelineStatistics;
+ };
+ static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct QueryPoolCreateInfo : public layout::QueryPoolCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(),
+ vk::QueryType queryType_ = vk::QueryType::eOcclusion,
+ uint32_t queryCount_ = 0,
+ vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() )
+ : layout::QueryPoolCreateInfo( flags_, queryType_, queryCount_, pipelineStatistics_ )
{}
QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
- }
+ : layout::QueryPoolCreateInfo( rhs )
+ {}
QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
+ layout::QueryPoolCreateInfo::operator=(rhs);
return *this;
}
@@ -44324,13 +57916,13 @@
return *this;
}
- QueryPoolCreateInfo & setFlags( QueryPoolCreateFlags flags_ )
+ QueryPoolCreateInfo & setFlags( vk::QueryPoolCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- QueryPoolCreateInfo & setQueryType( QueryType queryType_ )
+ QueryPoolCreateInfo & setQueryType( vk::QueryType queryType_ )
{
queryType = queryType_;
return *this;
@@ -44342,7 +57934,7 @@
return *this;
}
- QueryPoolCreateInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
+ QueryPoolCreateInfo & setPipelineStatistics( vk::QueryPipelineStatisticFlags pipelineStatistics_ )
{
pipelineStatistics = pipelineStatistics_;
return *this;
@@ -44374,31 +57966,52 @@
}
private:
- StructureType sType = StructureType::eQueryPoolCreateInfo;
-
- public:
- const void* pNext = nullptr;
- QueryPoolCreateFlags flags;
- QueryType queryType;
- uint32_t queryCount;
- QueryPipelineStatisticFlags pipelineStatistics;
+ using layout::QueryPoolCreateInfo::sType;
};
static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<QueryPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct QueryPoolCreateInfoINTEL
+ namespace layout
{
- QueryPoolCreateInfoINTEL( QueryPoolSamplingModeINTEL performanceCountersSampling_ = QueryPoolSamplingModeINTEL::eManual )
- : performanceCountersSampling( performanceCountersSampling_ )
+ struct QueryPoolCreateInfoINTEL
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual )
+ : performanceCountersSampling( performanceCountersSampling_ )
+ {}
+
+ QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
+ }
+
+ QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs )
+ {
+ *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL;
+ const void* pNext = nullptr;
+ vk::QueryPoolSamplingModeINTEL performanceCountersSampling;
+ };
+ static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "layout struct and wrapper have different size!" );
+ }
+
+ struct QueryPoolCreateInfoINTEL : public layout::QueryPoolCreateInfoINTEL
+ {
+ VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual )
+ : layout::QueryPoolCreateInfoINTEL( performanceCountersSampling_ )
{}
QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs )
- {
- memcpy( this, &rhs, sizeof( QueryPoolCreateInfoINTEL ) );
- }
+ : layout::QueryPoolCreateInfoINTEL( rhs )
+ {}
QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs )
{
- memcpy( this, &rhs, sizeof( QueryPoolCreateInfoINTEL ) );
+ layout::QueryPoolCreateInfoINTEL::operator=(rhs);
return *this;
}
@@ -44408,7 +58021,7 @@
return *this;
}
- QueryPoolCreateInfoINTEL & setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ )
+ QueryPoolCreateInfoINTEL & setPerformanceCountersSampling( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ )
{
performanceCountersSampling = performanceCountersSampling_;
return *this;
@@ -44437,16 +58050,54 @@
}
private:
- StructureType sType = StructureType::eQueryPoolCreateInfoINTEL;
-
- public:
- const void* pNext = nullptr;
- QueryPoolSamplingModeINTEL performanceCountersSampling;
+ using layout::QueryPoolCreateInfoINTEL::sType;
};
static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<QueryPoolCreateInfoINTEL>::value, "struct wrapper is not a standard layout!" );
- struct QueueFamilyCheckpointPropertiesNV
+ namespace layout
{
+ struct QueueFamilyCheckpointPropertiesNV
+ {
+ protected:
+ QueueFamilyCheckpointPropertiesNV()
+ {}
+
+ QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
+ }
+
+ QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs )
+ {
+ *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
+ void* pNext = nullptr;
+ vk::PipelineStageFlags checkpointExecutionStageMask;
+ };
+ static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct QueueFamilyCheckpointPropertiesNV : public layout::QueueFamilyCheckpointPropertiesNV
+ {
+ QueueFamilyCheckpointPropertiesNV()
+ : layout::QueueFamilyCheckpointPropertiesNV()
+ {}
+
+ QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs )
+ : layout::QueueFamilyCheckpointPropertiesNV( rhs )
+ {}
+
+ QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs )
+ {
+ layout::QueueFamilyCheckpointPropertiesNV::operator=(rhs);
+ return *this;
+ }
+
operator VkQueueFamilyCheckpointPropertiesNV const&() const
{
return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>( this );
@@ -44470,16 +58121,27 @@
}
private:
- StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV;
-
- public:
- void* pNext = nullptr;
- PipelineStageFlags checkpointExecutionStageMask;
+ using layout::QueueFamilyCheckpointPropertiesNV::sType;
};
static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<QueueFamilyCheckpointPropertiesNV>::value, "struct wrapper is not a standard layout!" );
struct QueueFamilyProperties
{
+ QueueFamilyProperties()
+ {}
+
+ QueueFamilyProperties( VkQueueFamilyProperties const & rhs )
+ {
+ *reinterpret_cast<VkQueueFamilyProperties*>(this) = rhs;
+ }
+
+ QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs )
+ {
+ *reinterpret_cast<VkQueueFamilyProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkQueueFamilyProperties const&() const
{
return *reinterpret_cast<const VkQueueFamilyProperties*>( this );
@@ -44503,15 +58165,58 @@
return !operator==( rhs );
}
- QueueFlags queueFlags;
+ public:
+ vk::QueueFlags queueFlags;
uint32_t queueCount;
uint32_t timestampValidBits;
- Extent3D minImageTransferGranularity;
+ vk::Extent3D minImageTransferGranularity;
};
static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<QueueFamilyProperties>::value, "struct wrapper is not a standard layout!" );
- struct QueueFamilyProperties2
+ namespace layout
{
+ struct QueueFamilyProperties2
+ {
+ protected:
+ QueueFamilyProperties2()
+ {}
+
+ QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkQueueFamilyProperties2*>(this) = rhs;
+ }
+
+ QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkQueueFamilyProperties2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eQueueFamilyProperties2;
+ void* pNext = nullptr;
+ vk::QueueFamilyProperties queueFamilyProperties;
+ };
+ static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct QueueFamilyProperties2 : public layout::QueueFamilyProperties2
+ {
+ QueueFamilyProperties2()
+ : layout::QueueFamilyProperties2()
+ {}
+
+ QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs )
+ : layout::QueueFamilyProperties2( rhs )
+ {}
+
+ QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs )
+ {
+ layout::QueueFamilyProperties2::operator=(rhs);
+ return *this;
+ }
+
operator VkQueueFamilyProperties2 const&() const
{
return *reinterpret_cast<const VkQueueFamilyProperties2*>( this );
@@ -44535,36 +58240,68 @@
}
private:
- StructureType sType = StructureType::eQueueFamilyProperties2;
-
- public:
- void* pNext = nullptr;
- QueueFamilyProperties queueFamilyProperties;
+ using layout::QueueFamilyProperties2::sType;
};
static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<QueueFamilyProperties2>::value, "struct wrapper is not a standard layout!" );
- struct RayTracingShaderGroupCreateInfoNV
+ namespace layout
{
- RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeNV type_ = RayTracingShaderGroupTypeNV::eGeneral,
- uint32_t generalShader_ = 0,
- uint32_t closestHitShader_ = 0,
- uint32_t anyHitShader_ = 0,
- uint32_t intersectionShader_ = 0 )
- : type( type_ )
- , generalShader( generalShader_ )
- , closestHitShader( closestHitShader_ )
- , anyHitShader( anyHitShader_ )
- , intersectionShader( intersectionShader_ )
+ struct RayTracingShaderGroupCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral,
+ uint32_t generalShader_ = 0,
+ uint32_t closestHitShader_ = 0,
+ uint32_t anyHitShader_ = 0,
+ uint32_t intersectionShader_ = 0 )
+ : type( type_ )
+ , generalShader( generalShader_ )
+ , closestHitShader( closestHitShader_ )
+ , anyHitShader( anyHitShader_ )
+ , intersectionShader( intersectionShader_ )
+ {}
+
+ RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
+ }
+
+ RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::RayTracingShaderGroupTypeNV type;
+ uint32_t generalShader;
+ uint32_t closestHitShader;
+ uint32_t anyHitShader;
+ uint32_t intersectionShader;
+ };
+ static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RayTracingShaderGroupCreateInfoNV : public layout::RayTracingShaderGroupCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral,
+ uint32_t generalShader_ = 0,
+ uint32_t closestHitShader_ = 0,
+ uint32_t anyHitShader_ = 0,
+ uint32_t intersectionShader_ = 0 )
+ : layout::RayTracingShaderGroupCreateInfoNV( type_, generalShader_, closestHitShader_, anyHitShader_, intersectionShader_ )
{}
RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
- }
+ : layout::RayTracingShaderGroupCreateInfoNV( rhs )
+ {}
RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
+ layout::RayTracingShaderGroupCreateInfoNV::operator=(rhs);
return *this;
}
@@ -44574,7 +58311,7 @@
return *this;
}
- RayTracingShaderGroupCreateInfoNV & setType( RayTracingShaderGroupTypeNV type_ )
+ RayTracingShaderGroupCreateInfoNV & setType( vk::RayTracingShaderGroupTypeNV type_ )
{
type = type_;
return *this;
@@ -44631,48 +58368,84 @@
}
private:
- StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- RayTracingShaderGroupTypeNV type;
- uint32_t generalShader;
- uint32_t closestHitShader;
- uint32_t anyHitShader;
- uint32_t intersectionShader;
+ using layout::RayTracingShaderGroupCreateInfoNV::sType;
};
static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RayTracingShaderGroupCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
- struct RayTracingPipelineCreateInfoNV
+ namespace layout
{
- RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = PipelineCreateFlags(),
- uint32_t stageCount_ = 0,
- const PipelineShaderStageCreateInfo* pStages_ = nullptr,
- uint32_t groupCount_ = 0,
- const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
- uint32_t maxRecursionDepth_ = 0,
- PipelineLayout layout_ = PipelineLayout(),
- Pipeline basePipelineHandle_ = Pipeline(),
- int32_t basePipelineIndex_ = 0 )
- : flags( flags_ )
- , stageCount( stageCount_ )
- , pStages( pStages_ )
- , groupCount( groupCount_ )
- , pGroups( pGroups_ )
- , maxRecursionDepth( maxRecursionDepth_ )
- , layout( layout_ )
- , basePipelineHandle( basePipelineHandle_ )
- , basePipelineIndex( basePipelineIndex_ )
+ struct RayTracingPipelineCreateInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+ uint32_t stageCount_ = 0,
+ const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+ uint32_t groupCount_ = 0,
+ const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
+ uint32_t maxRecursionDepth_ = 0,
+ vk::PipelineLayout layout_ = vk::PipelineLayout(),
+ vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : flags( flags_ )
+ , stageCount( stageCount_ )
+ , pStages( pStages_ )
+ , groupCount( groupCount_ )
+ , pGroups( pGroups_ )
+ , maxRecursionDepth( maxRecursionDepth_ )
+ , layout( layout_ )
+ , basePipelineHandle( basePipelineHandle_ )
+ , basePipelineIndex( basePipelineIndex_ )
+ {}
+
+ RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
+ }
+
+ RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
+ const void* pNext = nullptr;
+ vk::PipelineCreateFlags flags;
+ uint32_t stageCount;
+ const vk::PipelineShaderStageCreateInfo* pStages;
+ uint32_t groupCount;
+ const vk::RayTracingShaderGroupCreateInfoNV* pGroups;
+ uint32_t maxRecursionDepth;
+ vk::PipelineLayout layout;
+ vk::Pipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+ };
+ static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RayTracingPipelineCreateInfoNV : public layout::RayTracingPipelineCreateInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(),
+ uint32_t stageCount_ = 0,
+ const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr,
+ uint32_t groupCount_ = 0,
+ const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
+ uint32_t maxRecursionDepth_ = 0,
+ vk::PipelineLayout layout_ = vk::PipelineLayout(),
+ vk::Pipeline basePipelineHandle_ = vk::Pipeline(),
+ int32_t basePipelineIndex_ = 0 )
+ : layout::RayTracingPipelineCreateInfoNV( flags_, stageCount_, pStages_, groupCount_, pGroups_, maxRecursionDepth_, layout_, basePipelineHandle_, basePipelineIndex_ )
{}
RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
- }
+ : layout::RayTracingPipelineCreateInfoNV( rhs )
+ {}
RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
+ layout::RayTracingPipelineCreateInfoNV::operator=(rhs);
return *this;
}
@@ -44682,7 +58455,7 @@
return *this;
}
- RayTracingPipelineCreateInfoNV & setFlags( PipelineCreateFlags flags_ )
+ RayTracingPipelineCreateInfoNV & setFlags( vk::PipelineCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -44694,7 +58467,7 @@
return *this;
}
- RayTracingPipelineCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo* pStages_ )
+ RayTracingPipelineCreateInfoNV & setPStages( const vk::PipelineShaderStageCreateInfo* pStages_ )
{
pStages = pStages_;
return *this;
@@ -44706,7 +58479,7 @@
return *this;
}
- RayTracingPipelineCreateInfoNV & setPGroups( const RayTracingShaderGroupCreateInfoNV* pGroups_ )
+ RayTracingPipelineCreateInfoNV & setPGroups( const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ )
{
pGroups = pGroups_;
return *this;
@@ -44718,13 +58491,13 @@
return *this;
}
- RayTracingPipelineCreateInfoNV & setLayout( PipelineLayout layout_ )
+ RayTracingPipelineCreateInfoNV & setLayout( vk::PipelineLayout layout_ )
{
layout = layout_;
return *this;
}
- RayTracingPipelineCreateInfoNV & setBasePipelineHandle( Pipeline basePipelineHandle_ )
+ RayTracingPipelineCreateInfoNV & setBasePipelineHandle( vk::Pipeline basePipelineHandle_ )
{
basePipelineHandle = basePipelineHandle_;
return *this;
@@ -44767,24 +58540,27 @@
}
private:
- StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV;
-
- public:
- const void* pNext = nullptr;
- PipelineCreateFlags flags;
- uint32_t stageCount;
- const PipelineShaderStageCreateInfo* pStages;
- uint32_t groupCount;
- const RayTracingShaderGroupCreateInfoNV* pGroups;
- uint32_t maxRecursionDepth;
- PipelineLayout layout;
- Pipeline basePipelineHandle;
- int32_t basePipelineIndex;
+ using layout::RayTracingPipelineCreateInfoNV::sType;
};
static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RayTracingPipelineCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
struct RefreshCycleDurationGOOGLE
{
+ RefreshCycleDurationGOOGLE()
+ {}
+
+ RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs )
+ {
+ *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this) = rhs;
+ }
+
+ RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs )
+ {
+ *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this) = rhs;
+ return *this;
+ }
+
operator VkRefreshCycleDurationGOOGLE const&() const
{
return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>( this );
@@ -44805,32 +58581,164 @@
return !operator==( rhs );
}
+ public:
uint64_t refreshDuration;
};
static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RefreshCycleDurationGOOGLE>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassBeginInfo
+ namespace layout
{
- RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(),
- Framebuffer framebuffer_ = Framebuffer(),
- Rect2D renderArea_ = Rect2D(),
- uint32_t clearValueCount_ = 0,
- const ClearValue* pClearValues_ = nullptr )
- : renderPass( renderPass_ )
- , framebuffer( framebuffer_ )
- , renderArea( renderArea_ )
- , clearValueCount( clearValueCount_ )
- , pClearValues( pClearValues_ )
+ struct RenderPassAttachmentBeginInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
+ const vk::ImageView* pAttachments_ = nullptr )
+ : attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ {}
+
+ RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
+ }
+
+ RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t attachmentCount;
+ const vk::ImageView* pAttachments;
+ };
+ static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassAttachmentBeginInfoKHR : public layout::RenderPassAttachmentBeginInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0,
+ const vk::ImageView* pAttachments_ = nullptr )
+ : layout::RenderPassAttachmentBeginInfoKHR( attachmentCount_, pAttachments_ )
+ {}
+
+ RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs )
+ : layout::RenderPassAttachmentBeginInfoKHR( rhs )
+ {}
+
+ RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs )
+ {
+ layout::RenderPassAttachmentBeginInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ RenderPassAttachmentBeginInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ RenderPassAttachmentBeginInfoKHR & setAttachmentCount( uint32_t attachmentCount_ )
+ {
+ attachmentCount = attachmentCount_;
+ return *this;
+ }
+
+ RenderPassAttachmentBeginInfoKHR & setPAttachments( const vk::ImageView* pAttachments_ )
+ {
+ pAttachments = pAttachments_;
+ return *this;
+ }
+
+ operator VkRenderPassAttachmentBeginInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkRenderPassAttachmentBeginInfoKHR*>( this );
+ }
+
+ operator VkRenderPassAttachmentBeginInfoKHR &()
+ {
+ return *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>( this );
+ }
+
+ bool operator==( RenderPassAttachmentBeginInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( attachmentCount == rhs.attachmentCount )
+ && ( pAttachments == rhs.pAttachments );
+ }
+
+ bool operator!=( RenderPassAttachmentBeginInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::RenderPassAttachmentBeginInfoKHR::sType;
+ };
+ static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassAttachmentBeginInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct RenderPassBeginInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+ vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+ vk::Rect2D renderArea_ = vk::Rect2D(),
+ uint32_t clearValueCount_ = 0,
+ const vk::ClearValue* pClearValues_ = nullptr )
+ : renderPass( renderPass_ )
+ , framebuffer( framebuffer_ )
+ , renderArea( renderArea_ )
+ , clearValueCount( clearValueCount_ )
+ , pClearValues( pClearValues_ )
+ {}
+
+ RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassBeginInfo*>(this) = rhs;
+ }
+
+ RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassBeginInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassBeginInfo;
+ const void* pNext = nullptr;
+ vk::RenderPass renderPass;
+ vk::Framebuffer framebuffer;
+ vk::Rect2D renderArea;
+ uint32_t clearValueCount;
+ const vk::ClearValue* pClearValues;
+ };
+ static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassBeginInfo : public layout::RenderPassBeginInfo
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(),
+ vk::Framebuffer framebuffer_ = vk::Framebuffer(),
+ vk::Rect2D renderArea_ = vk::Rect2D(),
+ uint32_t clearValueCount_ = 0,
+ const vk::ClearValue* pClearValues_ = nullptr )
+ : layout::RenderPassBeginInfo( renderPass_, framebuffer_, renderArea_, clearValueCount_, pClearValues_ )
{}
RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
- }
+ : layout::RenderPassBeginInfo( rhs )
+ {}
RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
+ layout::RenderPassBeginInfo::operator=(rhs);
return *this;
}
@@ -44840,19 +58748,19 @@
return *this;
}
- RenderPassBeginInfo & setRenderPass( RenderPass renderPass_ )
+ RenderPassBeginInfo & setRenderPass( vk::RenderPass renderPass_ )
{
renderPass = renderPass_;
return *this;
}
- RenderPassBeginInfo & setFramebuffer( Framebuffer framebuffer_ )
+ RenderPassBeginInfo & setFramebuffer( vk::Framebuffer framebuffer_ )
{
framebuffer = framebuffer_;
return *this;
}
- RenderPassBeginInfo & setRenderArea( Rect2D renderArea_ )
+ RenderPassBeginInfo & setRenderArea( vk::Rect2D renderArea_ )
{
renderArea = renderArea_;
return *this;
@@ -44864,7 +58772,7 @@
return *this;
}
- RenderPassBeginInfo & setPClearValues( const ClearValue* pClearValues_ )
+ RenderPassBeginInfo & setPClearValues( const vk::ClearValue* pClearValues_ )
{
pClearValues = pClearValues_;
return *this;
@@ -44897,30 +58805,23 @@
}
private:
- StructureType sType = StructureType::eRenderPassBeginInfo;
-
- public:
- const void* pNext = nullptr;
- RenderPass renderPass;
- Framebuffer framebuffer;
- Rect2D renderArea;
- uint32_t clearValueCount;
- const ClearValue* pClearValues;
+ using layout::RenderPassBeginInfo::sType;
};
static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
struct SubpassDescription
{
- 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 )
+ VULKAN_HPP_CONSTEXPR SubpassDescription( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
+ vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ uint32_t inputAttachmentCount_ = 0,
+ const vk::AttachmentReference* pInputAttachments_ = nullptr,
+ uint32_t colorAttachmentCount_ = 0,
+ const vk::AttachmentReference* pColorAttachments_ = nullptr,
+ const vk::AttachmentReference* pResolveAttachments_ = nullptr,
+ const vk::AttachmentReference* pDepthStencilAttachment_ = nullptr,
+ uint32_t preserveAttachmentCount_ = 0,
+ const uint32_t* pPreserveAttachments_ = nullptr )
: flags( flags_ )
, pipelineBindPoint( pipelineBindPoint_ )
, inputAttachmentCount( inputAttachmentCount_ )
@@ -44935,22 +58836,22 @@
SubpassDescription( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription ) );
+ *reinterpret_cast<VkSubpassDescription*>(this) = rhs;
}
SubpassDescription& operator=( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription ) );
+ *reinterpret_cast<VkSubpassDescription*>(this) = rhs;
return *this;
}
- SubpassDescription & setFlags( SubpassDescriptionFlags flags_ )
+ SubpassDescription & setFlags( vk::SubpassDescriptionFlags flags_ )
{
flags = flags_;
return *this;
}
- SubpassDescription & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ SubpassDescription & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
{
pipelineBindPoint = pipelineBindPoint_;
return *this;
@@ -44962,7 +58863,7 @@
return *this;
}
- SubpassDescription & setPInputAttachments( const AttachmentReference* pInputAttachments_ )
+ SubpassDescription & setPInputAttachments( const vk::AttachmentReference* pInputAttachments_ )
{
pInputAttachments = pInputAttachments_;
return *this;
@@ -44974,19 +58875,19 @@
return *this;
}
- SubpassDescription & setPColorAttachments( const AttachmentReference* pColorAttachments_ )
+ SubpassDescription & setPColorAttachments( const vk::AttachmentReference* pColorAttachments_ )
{
pColorAttachments = pColorAttachments_;
return *this;
}
- SubpassDescription & setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
+ SubpassDescription & setPResolveAttachments( const vk::AttachmentReference* pResolveAttachments_ )
{
pResolveAttachments = pResolveAttachments_;
return *this;
}
- SubpassDescription & setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
+ SubpassDescription & setPDepthStencilAttachment( const vk::AttachmentReference* pDepthStencilAttachment_ )
{
pDepthStencilAttachment = pDepthStencilAttachment_;
return *this;
@@ -45033,28 +58934,30 @@
return !operator==( rhs );
}
- SubpassDescriptionFlags flags;
- PipelineBindPoint pipelineBindPoint;
+ public:
+ vk::SubpassDescriptionFlags flags;
+ vk::PipelineBindPoint pipelineBindPoint;
uint32_t inputAttachmentCount;
- const AttachmentReference* pInputAttachments;
+ const vk::AttachmentReference* pInputAttachments;
uint32_t colorAttachmentCount;
- const AttachmentReference* pColorAttachments;
- const AttachmentReference* pResolveAttachments;
- const AttachmentReference* pDepthStencilAttachment;
+ const vk::AttachmentReference* pColorAttachments;
+ const vk::AttachmentReference* pResolveAttachments;
+ const vk::AttachmentReference* pDepthStencilAttachment;
uint32_t preserveAttachmentCount;
const uint32_t* pPreserveAttachments;
};
static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassDescription>::value, "struct wrapper is not a standard layout!" );
struct SubpassDependency
{
- SubpassDependency( uint32_t srcSubpass_ = 0,
- uint32_t dstSubpass_ = 0,
- PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
- PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
- AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- DependencyFlags dependencyFlags_ = DependencyFlags() )
+ VULKAN_HPP_CONSTEXPR SubpassDependency( uint32_t srcSubpass_ = 0,
+ uint32_t dstSubpass_ = 0,
+ vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(),
+ vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(),
+ vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags() )
: srcSubpass( srcSubpass_ )
, dstSubpass( dstSubpass_ )
, srcStageMask( srcStageMask_ )
@@ -45066,12 +58969,12 @@
SubpassDependency( VkSubpassDependency const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDependency ) );
+ *reinterpret_cast<VkSubpassDependency*>(this) = rhs;
}
SubpassDependency& operator=( VkSubpassDependency const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDependency ) );
+ *reinterpret_cast<VkSubpassDependency*>(this) = rhs;
return *this;
}
@@ -45087,31 +58990,31 @@
return *this;
}
- SubpassDependency & setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ SubpassDependency & setSrcStageMask( vk::PipelineStageFlags srcStageMask_ )
{
srcStageMask = srcStageMask_;
return *this;
}
- SubpassDependency & setDstStageMask( PipelineStageFlags dstStageMask_ )
+ SubpassDependency & setDstStageMask( vk::PipelineStageFlags dstStageMask_ )
{
dstStageMask = dstStageMask_;
return *this;
}
- SubpassDependency & setSrcAccessMask( AccessFlags srcAccessMask_ )
+ SubpassDependency & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
{
srcAccessMask = srcAccessMask_;
return *this;
}
- SubpassDependency & setDstAccessMask( AccessFlags dstAccessMask_ )
+ SubpassDependency & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
{
dstAccessMask = dstAccessMask_;
return *this;
}
- SubpassDependency & setDependencyFlags( DependencyFlags dependencyFlags_ )
+ SubpassDependency & setDependencyFlags( vk::DependencyFlags dependencyFlags_ )
{
dependencyFlags = dependencyFlags_;
return *this;
@@ -45143,42 +59046,83 @@
return !operator==( rhs );
}
+ public:
uint32_t srcSubpass;
uint32_t dstSubpass;
- PipelineStageFlags srcStageMask;
- PipelineStageFlags dstStageMask;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- DependencyFlags dependencyFlags;
+ vk::PipelineStageFlags srcStageMask;
+ vk::PipelineStageFlags dstStageMask;
+ vk::AccessFlags srcAccessMask;
+ vk::AccessFlags dstAccessMask;
+ vk::DependencyFlags dependencyFlags;
};
static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassDependency>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , subpassCount( subpassCount_ )
- , pSubpasses( pSubpasses_ )
- , dependencyCount( dependencyCount_ )
- , pDependencies( pDependencies_ )
+ struct RenderPassCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
+ uint32_t attachmentCount_ = 0,
+ const vk::AttachmentDescription* pAttachments_ = nullptr,
+ uint32_t subpassCount_ = 0,
+ const vk::SubpassDescription* pSubpasses_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const vk::SubpassDependency* pDependencies_ = nullptr )
+ : flags( flags_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , subpassCount( subpassCount_ )
+ , pSubpasses( pSubpasses_ )
+ , dependencyCount( dependencyCount_ )
+ , pDependencies( pDependencies_ )
+ {}
+
+ RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassCreateInfo*>(this) = rhs;
+ }
+
+ RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassCreateInfo;
+ const void* pNext = nullptr;
+ vk::RenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const vk::AttachmentDescription* pAttachments;
+ uint32_t subpassCount;
+ const vk::SubpassDescription* pSubpasses;
+ uint32_t dependencyCount;
+ const vk::SubpassDependency* pDependencies;
+ };
+ static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassCreateInfo : public layout::RenderPassCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
+ uint32_t attachmentCount_ = 0,
+ const vk::AttachmentDescription* pAttachments_ = nullptr,
+ uint32_t subpassCount_ = 0,
+ const vk::SubpassDescription* pSubpasses_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const vk::SubpassDependency* pDependencies_ = nullptr )
+ : layout::RenderPassCreateInfo( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_ )
{}
RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
- }
+ : layout::RenderPassCreateInfo( rhs )
+ {}
RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
+ layout::RenderPassCreateInfo::operator=(rhs);
return *this;
}
@@ -45188,7 +59132,7 @@
return *this;
}
- RenderPassCreateInfo & setFlags( RenderPassCreateFlags flags_ )
+ RenderPassCreateInfo & setFlags( vk::RenderPassCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -45200,7 +59144,7 @@
return *this;
}
- RenderPassCreateInfo & setPAttachments( const AttachmentDescription* pAttachments_ )
+ RenderPassCreateInfo & setPAttachments( const vk::AttachmentDescription* pAttachments_ )
{
pAttachments = pAttachments_;
return *this;
@@ -45212,7 +59156,7 @@
return *this;
}
- RenderPassCreateInfo & setPSubpasses( const SubpassDescription* pSubpasses_ )
+ RenderPassCreateInfo & setPSubpasses( const vk::SubpassDescription* pSubpasses_ )
{
pSubpasses = pSubpasses_;
return *this;
@@ -45224,7 +59168,7 @@
return *this;
}
- RenderPassCreateInfo & setPDependencies( const SubpassDependency* pDependencies_ )
+ RenderPassCreateInfo & setPDependencies( const vk::SubpassDependency* pDependencies_ )
{
pDependencies = pDependencies_;
return *this;
@@ -45259,54 +59203,92 @@
}
private:
- StructureType sType = StructureType::eRenderPassCreateInfo;
-
- public:
- const void* pNext = nullptr;
- RenderPassCreateFlags flags;
- uint32_t attachmentCount;
- const AttachmentDescription* pAttachments;
- uint32_t subpassCount;
- const SubpassDescription* pSubpasses;
- uint32_t dependencyCount;
- const SubpassDependency* pDependencies;
+ using layout::RenderPassCreateInfo::sType;
};
static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct SubpassDescription2KHR
+ namespace layout
{
- SubpassDescription2KHR( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(),
- PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics,
- uint32_t viewMask_ = 0,
- uint32_t inputAttachmentCount_ = 0,
- const AttachmentReference2KHR* pInputAttachments_ = nullptr,
- uint32_t colorAttachmentCount_ = 0,
- const AttachmentReference2KHR* pColorAttachments_ = nullptr,
- const AttachmentReference2KHR* pResolveAttachments_ = nullptr,
- const AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
- uint32_t preserveAttachmentCount_ = 0,
- const uint32_t* pPreserveAttachments_ = nullptr )
- : flags( flags_ )
- , pipelineBindPoint( pipelineBindPoint_ )
- , viewMask( viewMask_ )
- , inputAttachmentCount( inputAttachmentCount_ )
- , pInputAttachments( pInputAttachments_ )
- , colorAttachmentCount( colorAttachmentCount_ )
- , pColorAttachments( pColorAttachments_ )
- , pResolveAttachments( pResolveAttachments_ )
- , pDepthStencilAttachment( pDepthStencilAttachment_ )
- , preserveAttachmentCount( preserveAttachmentCount_ )
- , pPreserveAttachments( pPreserveAttachments_ )
+ struct SubpassDescription2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
+ vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ uint32_t viewMask_ = 0,
+ uint32_t inputAttachmentCount_ = 0,
+ const vk::AttachmentReference2KHR* pInputAttachments_ = nullptr,
+ uint32_t colorAttachmentCount_ = 0,
+ const vk::AttachmentReference2KHR* pColorAttachments_ = nullptr,
+ const vk::AttachmentReference2KHR* pResolveAttachments_ = nullptr,
+ const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
+ uint32_t preserveAttachmentCount_ = 0,
+ const uint32_t* pPreserveAttachments_ = nullptr )
+ : flags( flags_ )
+ , pipelineBindPoint( pipelineBindPoint_ )
+ , viewMask( viewMask_ )
+ , inputAttachmentCount( inputAttachmentCount_ )
+ , pInputAttachments( pInputAttachments_ )
+ , colorAttachmentCount( colorAttachmentCount_ )
+ , pColorAttachments( pColorAttachments_ )
+ , pResolveAttachments( pResolveAttachments_ )
+ , pDepthStencilAttachment( pDepthStencilAttachment_ )
+ , preserveAttachmentCount( preserveAttachmentCount_ )
+ , pPreserveAttachments( pPreserveAttachments_ )
+ {}
+
+ SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassDescription2KHR*>(this) = rhs;
+ }
+
+ SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassDescription2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSubpassDescription2KHR;
+ const void* pNext = nullptr;
+ vk::SubpassDescriptionFlags flags;
+ vk::PipelineBindPoint pipelineBindPoint;
+ uint32_t viewMask;
+ uint32_t inputAttachmentCount;
+ const vk::AttachmentReference2KHR* pInputAttachments;
+ uint32_t colorAttachmentCount;
+ const vk::AttachmentReference2KHR* pColorAttachments;
+ const vk::AttachmentReference2KHR* pResolveAttachments;
+ const vk::AttachmentReference2KHR* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const uint32_t* pPreserveAttachments;
+ };
+ static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SubpassDescription2KHR : public layout::SubpassDescription2KHR
+ {
+ VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(),
+ vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics,
+ uint32_t viewMask_ = 0,
+ uint32_t inputAttachmentCount_ = 0,
+ const vk::AttachmentReference2KHR* pInputAttachments_ = nullptr,
+ uint32_t colorAttachmentCount_ = 0,
+ const vk::AttachmentReference2KHR* pColorAttachments_ = nullptr,
+ const vk::AttachmentReference2KHR* pResolveAttachments_ = nullptr,
+ const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
+ uint32_t preserveAttachmentCount_ = 0,
+ const uint32_t* pPreserveAttachments_ = nullptr )
+ : layout::SubpassDescription2KHR( flags_, pipelineBindPoint_, viewMask_, inputAttachmentCount_, pInputAttachments_, colorAttachmentCount_, pColorAttachments_, pResolveAttachments_, pDepthStencilAttachment_, preserveAttachmentCount_, pPreserveAttachments_ )
{}
SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
- }
+ : layout::SubpassDescription2KHR( rhs )
+ {}
SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
+ layout::SubpassDescription2KHR::operator=(rhs);
return *this;
}
@@ -45316,13 +59298,13 @@
return *this;
}
- SubpassDescription2KHR & setFlags( SubpassDescriptionFlags flags_ )
+ SubpassDescription2KHR & setFlags( vk::SubpassDescriptionFlags flags_ )
{
flags = flags_;
return *this;
}
- SubpassDescription2KHR & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
+ SubpassDescription2KHR & setPipelineBindPoint( vk::PipelineBindPoint pipelineBindPoint_ )
{
pipelineBindPoint = pipelineBindPoint_;
return *this;
@@ -45340,7 +59322,7 @@
return *this;
}
- SubpassDescription2KHR & setPInputAttachments( const AttachmentReference2KHR* pInputAttachments_ )
+ SubpassDescription2KHR & setPInputAttachments( const vk::AttachmentReference2KHR* pInputAttachments_ )
{
pInputAttachments = pInputAttachments_;
return *this;
@@ -45352,19 +59334,19 @@
return *this;
}
- SubpassDescription2KHR & setPColorAttachments( const AttachmentReference2KHR* pColorAttachments_ )
+ SubpassDescription2KHR & setPColorAttachments( const vk::AttachmentReference2KHR* pColorAttachments_ )
{
pColorAttachments = pColorAttachments_;
return *this;
}
- SubpassDescription2KHR & setPResolveAttachments( const AttachmentReference2KHR* pResolveAttachments_ )
+ SubpassDescription2KHR & setPResolveAttachments( const vk::AttachmentReference2KHR* pResolveAttachments_ )
{
pResolveAttachments = pResolveAttachments_;
return *this;
}
- SubpassDescription2KHR & setPDepthStencilAttachment( const AttachmentReference2KHR* pDepthStencilAttachment_ )
+ SubpassDescription2KHR & setPDepthStencilAttachment( const vk::AttachmentReference2KHR* pDepthStencilAttachment_ )
{
pDepthStencilAttachment = pDepthStencilAttachment_;
return *this;
@@ -45415,52 +59397,80 @@
}
private:
- StructureType sType = StructureType::eSubpassDescription2KHR;
-
- public:
- const void* pNext = nullptr;
- SubpassDescriptionFlags flags;
- PipelineBindPoint pipelineBindPoint;
- uint32_t viewMask;
- uint32_t inputAttachmentCount;
- const AttachmentReference2KHR* pInputAttachments;
- uint32_t colorAttachmentCount;
- const AttachmentReference2KHR* pColorAttachments;
- const AttachmentReference2KHR* pResolveAttachments;
- const AttachmentReference2KHR* pDepthStencilAttachment;
- uint32_t preserveAttachmentCount;
- const uint32_t* pPreserveAttachments;
+ using layout::SubpassDescription2KHR::sType;
};
static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassDescription2KHR>::value, "struct wrapper is not a standard layout!" );
- struct SubpassDependency2KHR
+ namespace layout
{
- SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
- uint32_t dstSubpass_ = 0,
- PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
- PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
- AccessFlags srcAccessMask_ = AccessFlags(),
- AccessFlags dstAccessMask_ = AccessFlags(),
- DependencyFlags dependencyFlags_ = DependencyFlags(),
- int32_t viewOffset_ = 0 )
- : srcSubpass( srcSubpass_ )
- , dstSubpass( dstSubpass_ )
- , srcStageMask( srcStageMask_ )
- , dstStageMask( dstStageMask_ )
- , srcAccessMask( srcAccessMask_ )
- , dstAccessMask( dstAccessMask_ )
- , dependencyFlags( dependencyFlags_ )
- , viewOffset( viewOffset_ )
+ struct SubpassDependency2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
+ uint32_t dstSubpass_ = 0,
+ vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(),
+ vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(),
+ vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(),
+ int32_t viewOffset_ = 0 )
+ : srcSubpass( srcSubpass_ )
+ , dstSubpass( dstSubpass_ )
+ , srcStageMask( srcStageMask_ )
+ , dstStageMask( dstStageMask_ )
+ , srcAccessMask( srcAccessMask_ )
+ , dstAccessMask( dstAccessMask_ )
+ , dependencyFlags( dependencyFlags_ )
+ , viewOffset( viewOffset_ )
+ {}
+
+ SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassDependency2KHR*>(this) = rhs;
+ }
+
+ SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassDependency2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSubpassDependency2KHR;
+ const void* pNext = nullptr;
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ vk::PipelineStageFlags srcStageMask;
+ vk::PipelineStageFlags dstStageMask;
+ vk::AccessFlags srcAccessMask;
+ vk::AccessFlags dstAccessMask;
+ vk::DependencyFlags dependencyFlags;
+ int32_t viewOffset;
+ };
+ static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SubpassDependency2KHR : public layout::SubpassDependency2KHR
+ {
+ VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0,
+ uint32_t dstSubpass_ = 0,
+ vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(),
+ vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(),
+ vk::AccessFlags srcAccessMask_ = vk::AccessFlags(),
+ vk::AccessFlags dstAccessMask_ = vk::AccessFlags(),
+ vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(),
+ int32_t viewOffset_ = 0 )
+ : layout::SubpassDependency2KHR( srcSubpass_, dstSubpass_, srcStageMask_, dstStageMask_, srcAccessMask_, dstAccessMask_, dependencyFlags_, viewOffset_ )
{}
SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
- }
+ : layout::SubpassDependency2KHR( rhs )
+ {}
SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
+ layout::SubpassDependency2KHR::operator=(rhs);
return *this;
}
@@ -45482,31 +59492,31 @@
return *this;
}
- SubpassDependency2KHR & setSrcStageMask( PipelineStageFlags srcStageMask_ )
+ SubpassDependency2KHR & setSrcStageMask( vk::PipelineStageFlags srcStageMask_ )
{
srcStageMask = srcStageMask_;
return *this;
}
- SubpassDependency2KHR & setDstStageMask( PipelineStageFlags dstStageMask_ )
+ SubpassDependency2KHR & setDstStageMask( vk::PipelineStageFlags dstStageMask_ )
{
dstStageMask = dstStageMask_;
return *this;
}
- SubpassDependency2KHR & setSrcAccessMask( AccessFlags srcAccessMask_ )
+ SubpassDependency2KHR & setSrcAccessMask( vk::AccessFlags srcAccessMask_ )
{
srcAccessMask = srcAccessMask_;
return *this;
}
- SubpassDependency2KHR & setDstAccessMask( AccessFlags dstAccessMask_ )
+ SubpassDependency2KHR & setDstAccessMask( vk::AccessFlags dstAccessMask_ )
{
dstAccessMask = dstAccessMask_;
return *this;
}
- SubpassDependency2KHR & setDependencyFlags( DependencyFlags dependencyFlags_ )
+ SubpassDependency2KHR & setDependencyFlags( vk::DependencyFlags dependencyFlags_ )
{
dependencyFlags = dependencyFlags_;
return *this;
@@ -45548,51 +59558,84 @@
}
private:
- StructureType sType = StructureType::eSubpassDependency2KHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t srcSubpass;
- uint32_t dstSubpass;
- PipelineStageFlags srcStageMask;
- PipelineStageFlags dstStageMask;
- AccessFlags srcAccessMask;
- AccessFlags dstAccessMask;
- DependencyFlags dependencyFlags;
- int32_t viewOffset;
+ using layout::SubpassDependency2KHR::sType;
};
static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassDependency2KHR>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassCreateInfo2KHR
+ namespace layout
{
- RenderPassCreateInfo2KHR( RenderPassCreateFlags flags_ = RenderPassCreateFlags(),
- uint32_t attachmentCount_ = 0,
- const AttachmentDescription2KHR* pAttachments_ = nullptr,
- uint32_t subpassCount_ = 0,
- const SubpassDescription2KHR* pSubpasses_ = nullptr,
- uint32_t dependencyCount_ = 0,
- const SubpassDependency2KHR* pDependencies_ = nullptr,
- uint32_t correlatedViewMaskCount_ = 0,
- const uint32_t* pCorrelatedViewMasks_ = nullptr )
- : flags( flags_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , subpassCount( subpassCount_ )
- , pSubpasses( pSubpasses_ )
- , dependencyCount( dependencyCount_ )
- , pDependencies( pDependencies_ )
- , correlatedViewMaskCount( correlatedViewMaskCount_ )
- , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
+ struct RenderPassCreateInfo2KHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
+ uint32_t attachmentCount_ = 0,
+ const vk::AttachmentDescription2KHR* pAttachments_ = nullptr,
+ uint32_t subpassCount_ = 0,
+ const vk::SubpassDescription2KHR* pSubpasses_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const vk::SubpassDependency2KHR* pDependencies_ = nullptr,
+ uint32_t correlatedViewMaskCount_ = 0,
+ const uint32_t* pCorrelatedViewMasks_ = nullptr )
+ : flags( flags_ )
+ , attachmentCount( attachmentCount_ )
+ , pAttachments( pAttachments_ )
+ , subpassCount( subpassCount_ )
+ , pSubpasses( pSubpasses_ )
+ , dependencyCount( dependencyCount_ )
+ , pDependencies( pDependencies_ )
+ , correlatedViewMaskCount( correlatedViewMaskCount_ )
+ , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
+ {}
+
+ RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this) = rhs;
+ }
+
+ RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
+ const void* pNext = nullptr;
+ vk::RenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const vk::AttachmentDescription2KHR* pAttachments;
+ uint32_t subpassCount;
+ const vk::SubpassDescription2KHR* pSubpasses;
+ uint32_t dependencyCount;
+ const vk::SubpassDependency2KHR* pDependencies;
+ uint32_t correlatedViewMaskCount;
+ const uint32_t* pCorrelatedViewMasks;
+ };
+ static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassCreateInfo2KHR : public layout::RenderPassCreateInfo2KHR
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(),
+ uint32_t attachmentCount_ = 0,
+ const vk::AttachmentDescription2KHR* pAttachments_ = nullptr,
+ uint32_t subpassCount_ = 0,
+ const vk::SubpassDescription2KHR* pSubpasses_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const vk::SubpassDependency2KHR* pDependencies_ = nullptr,
+ uint32_t correlatedViewMaskCount_ = 0,
+ const uint32_t* pCorrelatedViewMasks_ = nullptr )
+ : layout::RenderPassCreateInfo2KHR( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_, correlatedViewMaskCount_, pCorrelatedViewMasks_ )
{}
RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
- }
+ : layout::RenderPassCreateInfo2KHR( rhs )
+ {}
RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
+ layout::RenderPassCreateInfo2KHR::operator=(rhs);
return *this;
}
@@ -45602,7 +59645,7 @@
return *this;
}
- RenderPassCreateInfo2KHR & setFlags( RenderPassCreateFlags flags_ )
+ RenderPassCreateInfo2KHR & setFlags( vk::RenderPassCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -45614,7 +59657,7 @@
return *this;
}
- RenderPassCreateInfo2KHR & setPAttachments( const AttachmentDescription2KHR* pAttachments_ )
+ RenderPassCreateInfo2KHR & setPAttachments( const vk::AttachmentDescription2KHR* pAttachments_ )
{
pAttachments = pAttachments_;
return *this;
@@ -45626,7 +59669,7 @@
return *this;
}
- RenderPassCreateInfo2KHR & setPSubpasses( const SubpassDescription2KHR* pSubpasses_ )
+ RenderPassCreateInfo2KHR & setPSubpasses( const vk::SubpassDescription2KHR* pSubpasses_ )
{
pSubpasses = pSubpasses_;
return *this;
@@ -45638,7 +59681,7 @@
return *this;
}
- RenderPassCreateInfo2KHR & setPDependencies( const SubpassDependency2KHR* pDependencies_ )
+ RenderPassCreateInfo2KHR & setPDependencies( const vk::SubpassDependency2KHR* pDependencies_ )
{
pDependencies = pDependencies_;
return *this;
@@ -45687,36 +59730,52 @@
}
private:
- StructureType sType = StructureType::eRenderPassCreateInfo2KHR;
-
- public:
- const void* pNext = nullptr;
- RenderPassCreateFlags flags;
- uint32_t attachmentCount;
- const AttachmentDescription2KHR* pAttachments;
- uint32_t subpassCount;
- const SubpassDescription2KHR* pSubpasses;
- uint32_t dependencyCount;
- const SubpassDependency2KHR* pDependencies;
- uint32_t correlatedViewMaskCount;
- const uint32_t* pCorrelatedViewMasks;
+ using layout::RenderPassCreateInfo2KHR::sType;
};
static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassCreateInfo2KHR>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassFragmentDensityMapCreateInfoEXT
+ namespace layout
{
- RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = AttachmentReference() )
- : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
+ struct RenderPassFragmentDensityMapCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() )
+ : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ )
+ {}
+
+ RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
+ }
+
+ RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::AttachmentReference fragmentDensityMapAttachment;
+ };
+ static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassFragmentDensityMapCreateInfoEXT : public layout::RenderPassFragmentDensityMapCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() )
+ : layout::RenderPassFragmentDensityMapCreateInfoEXT( fragmentDensityMapAttachment_ )
{}
RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
- }
+ : layout::RenderPassFragmentDensityMapCreateInfoEXT( rhs )
+ {}
RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) );
+ layout::RenderPassFragmentDensityMapCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -45726,7 +59785,7 @@
return *this;
}
- RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( AttachmentReference fragmentDensityMapAttachment_ )
+ RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( vk::AttachmentReference fragmentDensityMapAttachment_ )
{
fragmentDensityMapAttachment = fragmentDensityMapAttachment_;
return *this;
@@ -45755,30 +59814,56 @@
}
private:
- StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- AttachmentReference fragmentDensityMapAttachment;
+ using layout::RenderPassFragmentDensityMapCreateInfoEXT::sType;
};
static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassFragmentDensityMapCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassInputAttachmentAspectCreateInfo
+ namespace layout
{
- RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
- const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
- : aspectReferenceCount( aspectReferenceCount_ )
- , pAspectReferences( pAspectReferences_ )
+ struct RenderPassInputAttachmentAspectCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
+ const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr )
+ : aspectReferenceCount( aspectReferenceCount_ )
+ , pAspectReferences( pAspectReferences_ )
+ {}
+
+ RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
+ }
+
+ RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
+ const void* pNext = nullptr;
+ uint32_t aspectReferenceCount;
+ const vk::InputAttachmentAspectReference* pAspectReferences;
+ };
+ static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassInputAttachmentAspectCreateInfo : public layout::RenderPassInputAttachmentAspectCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0,
+ const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr )
+ : layout::RenderPassInputAttachmentAspectCreateInfo( aspectReferenceCount_, pAspectReferences_ )
{}
RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
- }
+ : layout::RenderPassInputAttachmentAspectCreateInfo( rhs )
+ {}
RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
+ layout::RenderPassInputAttachmentAspectCreateInfo::operator=(rhs);
return *this;
}
@@ -45794,7 +59879,7 @@
return *this;
}
- RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const InputAttachmentAspectReference* pAspectReferences_ )
+ RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const vk::InputAttachmentAspectReference* pAspectReferences_ )
{
pAspectReferences = pAspectReferences_;
return *this;
@@ -45824,39 +59909,72 @@
}
private:
- StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t aspectReferenceCount;
- const InputAttachmentAspectReference* pAspectReferences;
+ using layout::RenderPassInputAttachmentAspectCreateInfo::sType;
};
static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassInputAttachmentAspectCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassMultiviewCreateInfo
+ namespace layout
{
- RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
- const uint32_t* pViewMasks_ = nullptr,
- uint32_t dependencyCount_ = 0,
- const int32_t* pViewOffsets_ = nullptr,
- uint32_t correlationMaskCount_ = 0,
- const uint32_t* pCorrelationMasks_ = nullptr )
- : subpassCount( subpassCount_ )
- , pViewMasks( pViewMasks_ )
- , dependencyCount( dependencyCount_ )
- , pViewOffsets( pViewOffsets_ )
- , correlationMaskCount( correlationMaskCount_ )
- , pCorrelationMasks( pCorrelationMasks_ )
+ struct RenderPassMultiviewCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
+ const uint32_t* pViewMasks_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const int32_t* pViewOffsets_ = nullptr,
+ uint32_t correlationMaskCount_ = 0,
+ const uint32_t* pCorrelationMasks_ = nullptr )
+ : subpassCount( subpassCount_ )
+ , pViewMasks( pViewMasks_ )
+ , dependencyCount( dependencyCount_ )
+ , pViewOffsets( pViewOffsets_ )
+ , correlationMaskCount( correlationMaskCount_ )
+ , pCorrelationMasks( pCorrelationMasks_ )
+ {}
+
+ RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
+ }
+
+ RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
+ const void* pNext = nullptr;
+ uint32_t subpassCount;
+ const uint32_t* pViewMasks;
+ uint32_t dependencyCount;
+ const int32_t* pViewOffsets;
+ uint32_t correlationMaskCount;
+ const uint32_t* pCorrelationMasks;
+ };
+ static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassMultiviewCreateInfo : public layout::RenderPassMultiviewCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0,
+ const uint32_t* pViewMasks_ = nullptr,
+ uint32_t dependencyCount_ = 0,
+ const int32_t* pViewOffsets_ = nullptr,
+ uint32_t correlationMaskCount_ = 0,
+ const uint32_t* pCorrelationMasks_ = nullptr )
+ : layout::RenderPassMultiviewCreateInfo( subpassCount_, pViewMasks_, dependencyCount_, pViewOffsets_, correlationMaskCount_, pCorrelationMasks_ )
{}
RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
- }
+ : layout::RenderPassMultiviewCreateInfo( rhs )
+ {}
RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
+ layout::RenderPassMultiviewCreateInfo::operator=(rhs);
return *this;
}
@@ -45930,35 +60048,27 @@
}
private:
- StructureType sType = StructureType::eRenderPassMultiviewCreateInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t subpassCount;
- const uint32_t* pViewMasks;
- uint32_t dependencyCount;
- const int32_t* pViewOffsets;
- uint32_t correlationMaskCount;
- const uint32_t* pCorrelationMasks;
+ using layout::RenderPassMultiviewCreateInfo::sType;
};
static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassMultiviewCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct SubpassSampleLocationsEXT
{
- SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
- SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
+ VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0,
+ vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() )
: subpassIndex( subpassIndex_ )
, sampleLocationsInfo( sampleLocationsInfo_ )
{}
SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+ *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this) = rhs;
}
SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
+ *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this) = rhs;
return *this;
}
@@ -45968,7 +60078,7 @@
return *this;
}
- SubpassSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
+ SubpassSampleLocationsEXT & setSampleLocationsInfo( vk::SampleLocationsInfoEXT sampleLocationsInfo_ )
{
sampleLocationsInfo = sampleLocationsInfo_;
return *this;
@@ -45995,31 +60105,66 @@
return !operator==( rhs );
}
+ public:
uint32_t subpassIndex;
- SampleLocationsInfoEXT sampleLocationsInfo;
+ vk::SampleLocationsInfoEXT sampleLocationsInfo;
};
static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
- struct RenderPassSampleLocationsBeginInfoEXT
+ namespace layout
{
- RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
- const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
- uint32_t postSubpassSampleLocationsCount_ = 0,
- const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
- : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
- , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
- , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
- , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+ struct RenderPassSampleLocationsBeginInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
+ const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
+ uint32_t postSubpassSampleLocationsCount_ = 0,
+ const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
+ : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+ , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
+ , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
+ , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
+ {}
+
+ RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
+ }
+
+ RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
+ const void* pNext = nullptr;
+ uint32_t attachmentInitialSampleLocationsCount;
+ const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
+ uint32_t postSubpassSampleLocationsCount;
+ const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+ };
+ static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct RenderPassSampleLocationsBeginInfoEXT : public layout::RenderPassSampleLocationsBeginInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
+ const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
+ uint32_t postSubpassSampleLocationsCount_ = 0,
+ const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
+ : layout::RenderPassSampleLocationsBeginInfoEXT( attachmentInitialSampleLocationsCount_, pAttachmentInitialSampleLocations_, postSubpassSampleLocationsCount_, pPostSubpassSampleLocations_ )
{}
RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
- }
+ : layout::RenderPassSampleLocationsBeginInfoEXT( rhs )
+ {}
RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
+ layout::RenderPassSampleLocationsBeginInfoEXT::operator=(rhs);
return *this;
}
@@ -46035,7 +60180,7 @@
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
+ RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations( const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
{
pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
return *this;
@@ -46047,7 +60192,7 @@
return *this;
}
- RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
+ RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations( const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
{
pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
return *this;
@@ -46079,61 +60224,112 @@
}
private:
- StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t attachmentInitialSampleLocationsCount;
- const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
- uint32_t postSubpassSampleLocationsCount;
- const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
+ using layout::RenderPassSampleLocationsBeginInfoEXT::sType;
};
static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<RenderPassSampleLocationsBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct SamplerCreateInfo
+ namespace layout
{
- 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 )
- : flags( flags_ )
- , magFilter( magFilter_ )
- , minFilter( minFilter_ )
- , mipmapMode( mipmapMode_ )
- , addressModeU( addressModeU_ )
- , addressModeV( addressModeV_ )
- , addressModeW( addressModeW_ )
- , mipLodBias( mipLodBias_ )
- , anisotropyEnable( anisotropyEnable_ )
- , maxAnisotropy( maxAnisotropy_ )
- , compareEnable( compareEnable_ )
- , compareOp( compareOp_ )
- , minLod( minLod_ )
- , maxLod( maxLod_ )
- , borderColor( borderColor_ )
- , unnormalizedCoordinates( unnormalizedCoordinates_ )
+ struct SamplerCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(),
+ vk::Filter magFilter_ = vk::Filter::eNearest,
+ vk::Filter minFilter_ = vk::Filter::eNearest,
+ vk::SamplerMipmapMode mipmapMode_ = vk::SamplerMipmapMode::eNearest,
+ vk::SamplerAddressMode addressModeU_ = vk::SamplerAddressMode::eRepeat,
+ vk::SamplerAddressMode addressModeV_ = vk::SamplerAddressMode::eRepeat,
+ vk::SamplerAddressMode addressModeW_ = vk::SamplerAddressMode::eRepeat,
+ float mipLodBias_ = 0,
+ vk::Bool32 anisotropyEnable_ = 0,
+ float maxAnisotropy_ = 0,
+ vk::Bool32 compareEnable_ = 0,
+ vk::CompareOp compareOp_ = vk::CompareOp::eNever,
+ float minLod_ = 0,
+ float maxLod_ = 0,
+ vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack,
+ vk::Bool32 unnormalizedCoordinates_ = 0 )
+ : flags( flags_ )
+ , magFilter( magFilter_ )
+ , minFilter( minFilter_ )
+ , mipmapMode( mipmapMode_ )
+ , addressModeU( addressModeU_ )
+ , addressModeV( addressModeV_ )
+ , addressModeW( addressModeW_ )
+ , mipLodBias( mipLodBias_ )
+ , anisotropyEnable( anisotropyEnable_ )
+ , maxAnisotropy( maxAnisotropy_ )
+ , compareEnable( compareEnable_ )
+ , compareOp( compareOp_ )
+ , minLod( minLod_ )
+ , maxLod( maxLod_ )
+ , borderColor( borderColor_ )
+ , unnormalizedCoordinates( unnormalizedCoordinates_ )
+ {}
+
+ SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkSamplerCreateInfo*>(this) = rhs;
+ }
+
+ SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkSamplerCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSamplerCreateInfo;
+ const void* pNext = nullptr;
+ vk::SamplerCreateFlags flags;
+ vk::Filter magFilter;
+ vk::Filter minFilter;
+ vk::SamplerMipmapMode mipmapMode;
+ vk::SamplerAddressMode addressModeU;
+ vk::SamplerAddressMode addressModeV;
+ vk::SamplerAddressMode addressModeW;
+ float mipLodBias;
+ vk::Bool32 anisotropyEnable;
+ float maxAnisotropy;
+ vk::Bool32 compareEnable;
+ vk::CompareOp compareOp;
+ float minLod;
+ float maxLod;
+ vk::BorderColor borderColor;
+ vk::Bool32 unnormalizedCoordinates;
+ };
+ static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SamplerCreateInfo : public layout::SamplerCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(),
+ vk::Filter magFilter_ = vk::Filter::eNearest,
+ vk::Filter minFilter_ = vk::Filter::eNearest,
+ vk::SamplerMipmapMode mipmapMode_ = vk::SamplerMipmapMode::eNearest,
+ vk::SamplerAddressMode addressModeU_ = vk::SamplerAddressMode::eRepeat,
+ vk::SamplerAddressMode addressModeV_ = vk::SamplerAddressMode::eRepeat,
+ vk::SamplerAddressMode addressModeW_ = vk::SamplerAddressMode::eRepeat,
+ float mipLodBias_ = 0,
+ vk::Bool32 anisotropyEnable_ = 0,
+ float maxAnisotropy_ = 0,
+ vk::Bool32 compareEnable_ = 0,
+ vk::CompareOp compareOp_ = vk::CompareOp::eNever,
+ float minLod_ = 0,
+ float maxLod_ = 0,
+ vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack,
+ vk::Bool32 unnormalizedCoordinates_ = 0 )
+ : layout::SamplerCreateInfo( flags_, magFilter_, minFilter_, mipmapMode_, addressModeU_, addressModeV_, addressModeW_, mipLodBias_, anisotropyEnable_, maxAnisotropy_, compareEnable_, compareOp_, minLod_, maxLod_, borderColor_, unnormalizedCoordinates_ )
{}
SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
- }
+ : layout::SamplerCreateInfo( rhs )
+ {}
SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
+ layout::SamplerCreateInfo::operator=(rhs);
return *this;
}
@@ -46143,43 +60339,43 @@
return *this;
}
- SamplerCreateInfo & setFlags( SamplerCreateFlags flags_ )
+ SamplerCreateInfo & setFlags( vk::SamplerCreateFlags flags_ )
{
flags = flags_;
return *this;
}
- SamplerCreateInfo & setMagFilter( Filter magFilter_ )
+ SamplerCreateInfo & setMagFilter( vk::Filter magFilter_ )
{
magFilter = magFilter_;
return *this;
}
- SamplerCreateInfo & setMinFilter( Filter minFilter_ )
+ SamplerCreateInfo & setMinFilter( vk::Filter minFilter_ )
{
minFilter = minFilter_;
return *this;
}
- SamplerCreateInfo & setMipmapMode( SamplerMipmapMode mipmapMode_ )
+ SamplerCreateInfo & setMipmapMode( vk::SamplerMipmapMode mipmapMode_ )
{
mipmapMode = mipmapMode_;
return *this;
}
- SamplerCreateInfo & setAddressModeU( SamplerAddressMode addressModeU_ )
+ SamplerCreateInfo & setAddressModeU( vk::SamplerAddressMode addressModeU_ )
{
addressModeU = addressModeU_;
return *this;
}
- SamplerCreateInfo & setAddressModeV( SamplerAddressMode addressModeV_ )
+ SamplerCreateInfo & setAddressModeV( vk::SamplerAddressMode addressModeV_ )
{
addressModeV = addressModeV_;
return *this;
}
- SamplerCreateInfo & setAddressModeW( SamplerAddressMode addressModeW_ )
+ SamplerCreateInfo & setAddressModeW( vk::SamplerAddressMode addressModeW_ )
{
addressModeW = addressModeW_;
return *this;
@@ -46191,7 +60387,7 @@
return *this;
}
- SamplerCreateInfo & setAnisotropyEnable( Bool32 anisotropyEnable_ )
+ SamplerCreateInfo & setAnisotropyEnable( vk::Bool32 anisotropyEnable_ )
{
anisotropyEnable = anisotropyEnable_;
return *this;
@@ -46203,13 +60399,13 @@
return *this;
}
- SamplerCreateInfo & setCompareEnable( Bool32 compareEnable_ )
+ SamplerCreateInfo & setCompareEnable( vk::Bool32 compareEnable_ )
{
compareEnable = compareEnable_;
return *this;
}
- SamplerCreateInfo & setCompareOp( CompareOp compareOp_ )
+ SamplerCreateInfo & setCompareOp( vk::CompareOp compareOp_ )
{
compareOp = compareOp_;
return *this;
@@ -46227,13 +60423,13 @@
return *this;
}
- SamplerCreateInfo & setBorderColor( BorderColor borderColor_ )
+ SamplerCreateInfo & setBorderColor( vk::BorderColor borderColor_ )
{
borderColor = borderColor_;
return *this;
}
- SamplerCreateInfo & setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ )
+ SamplerCreateInfo & setUnnormalizedCoordinates( vk::Bool32 unnormalizedCoordinates_ )
{
unnormalizedCoordinates = unnormalizedCoordinates_;
return *this;
@@ -46277,43 +60473,52 @@
}
private:
- StructureType sType = StructureType::eSamplerCreateInfo;
-
- public:
- const void* pNext = nullptr;
- SamplerCreateFlags flags;
- Filter magFilter;
- Filter minFilter;
- SamplerMipmapMode mipmapMode;
- SamplerAddressMode addressModeU;
- SamplerAddressMode addressModeV;
- SamplerAddressMode addressModeW;
- float mipLodBias;
- Bool32 anisotropyEnable;
- float maxAnisotropy;
- Bool32 compareEnable;
- CompareOp compareOp;
- float minLod;
- float maxLod;
- BorderColor borderColor;
- Bool32 unnormalizedCoordinates;
+ using layout::SamplerCreateInfo::sType;
};
static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SamplerCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct SamplerReductionModeCreateInfoEXT
+ namespace layout
{
- SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
- : reductionMode( reductionMode_ )
+ struct SamplerReductionModeCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage )
+ : reductionMode( reductionMode_ )
+ {}
+
+ SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
+ }
+
+ SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::SamplerReductionModeEXT reductionMode;
+ };
+ static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SamplerReductionModeCreateInfoEXT : public layout::SamplerReductionModeCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage )
+ : layout::SamplerReductionModeCreateInfoEXT( reductionMode_ )
{}
SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
- }
+ : layout::SamplerReductionModeCreateInfoEXT( rhs )
+ {}
SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
+ layout::SamplerReductionModeCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -46323,7 +60528,7 @@
return *this;
}
- SamplerReductionModeCreateInfoEXT & setReductionMode( SamplerReductionModeEXT reductionMode_ )
+ SamplerReductionModeCreateInfoEXT & setReductionMode( vk::SamplerReductionModeEXT reductionMode_ )
{
reductionMode = reductionMode_;
return *this;
@@ -46352,42 +60557,80 @@
}
private:
- StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- SamplerReductionModeEXT reductionMode;
+ using layout::SamplerReductionModeCreateInfoEXT::sType;
};
static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SamplerReductionModeCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct SamplerYcbcrConversionCreateInfo
+ namespace layout
{
- SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined,
- SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity,
- SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull,
- ComponentMapping components_ = ComponentMapping(),
- ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven,
- ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven,
- Filter chromaFilter_ = Filter::eNearest,
- Bool32 forceExplicitReconstruction_ = 0 )
- : format( format_ )
- , ycbcrModel( ycbcrModel_ )
- , ycbcrRange( ycbcrRange_ )
- , components( components_ )
- , xChromaOffset( xChromaOffset_ )
- , yChromaOffset( yChromaOffset_ )
- , chromaFilter( chromaFilter_ )
- , forceExplicitReconstruction( forceExplicitReconstruction_ )
+ struct SamplerYcbcrConversionCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined,
+ vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity,
+ vk::SamplerYcbcrRange ycbcrRange_ = vk::SamplerYcbcrRange::eItuFull,
+ vk::ComponentMapping components_ = vk::ComponentMapping(),
+ vk::ChromaLocation xChromaOffset_ = vk::ChromaLocation::eCositedEven,
+ vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven,
+ vk::Filter chromaFilter_ = vk::Filter::eNearest,
+ vk::Bool32 forceExplicitReconstruction_ = 0 )
+ : format( format_ )
+ , ycbcrModel( ycbcrModel_ )
+ , ycbcrRange( ycbcrRange_ )
+ , components( components_ )
+ , xChromaOffset( xChromaOffset_ )
+ , yChromaOffset( yChromaOffset_ )
+ , chromaFilter( chromaFilter_ )
+ , forceExplicitReconstruction( forceExplicitReconstruction_ )
+ {}
+
+ SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
+ }
+
+ SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
+ const void* pNext = nullptr;
+ vk::Format format;
+ vk::SamplerYcbcrModelConversion ycbcrModel;
+ vk::SamplerYcbcrRange ycbcrRange;
+ vk::ComponentMapping components;
+ vk::ChromaLocation xChromaOffset;
+ vk::ChromaLocation yChromaOffset;
+ vk::Filter chromaFilter;
+ vk::Bool32 forceExplicitReconstruction;
+ };
+ static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SamplerYcbcrConversionCreateInfo : public layout::SamplerYcbcrConversionCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined,
+ vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity,
+ vk::SamplerYcbcrRange ycbcrRange_ = vk::SamplerYcbcrRange::eItuFull,
+ vk::ComponentMapping components_ = vk::ComponentMapping(),
+ vk::ChromaLocation xChromaOffset_ = vk::ChromaLocation::eCositedEven,
+ vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven,
+ vk::Filter chromaFilter_ = vk::Filter::eNearest,
+ vk::Bool32 forceExplicitReconstruction_ = 0 )
+ : layout::SamplerYcbcrConversionCreateInfo( format_, ycbcrModel_, ycbcrRange_, components_, xChromaOffset_, yChromaOffset_, chromaFilter_, forceExplicitReconstruction_ )
{}
SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
- }
+ : layout::SamplerYcbcrConversionCreateInfo( rhs )
+ {}
SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
+ layout::SamplerYcbcrConversionCreateInfo::operator=(rhs);
return *this;
}
@@ -46397,49 +60640,49 @@
return *this;
}
- SamplerYcbcrConversionCreateInfo & setFormat( Format format_ )
+ SamplerYcbcrConversionCreateInfo & setFormat( vk::Format format_ )
{
format = format_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ )
+ SamplerYcbcrConversionCreateInfo & setYcbcrModel( vk::SamplerYcbcrModelConversion ycbcrModel_ )
{
ycbcrModel = ycbcrModel_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setYcbcrRange( SamplerYcbcrRange ycbcrRange_ )
+ SamplerYcbcrConversionCreateInfo & setYcbcrRange( vk::SamplerYcbcrRange ycbcrRange_ )
{
ycbcrRange = ycbcrRange_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setComponents( ComponentMapping components_ )
+ SamplerYcbcrConversionCreateInfo & setComponents( vk::ComponentMapping components_ )
{
components = components_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setXChromaOffset( ChromaLocation xChromaOffset_ )
+ SamplerYcbcrConversionCreateInfo & setXChromaOffset( vk::ChromaLocation xChromaOffset_ )
{
xChromaOffset = xChromaOffset_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setYChromaOffset( ChromaLocation yChromaOffset_ )
+ SamplerYcbcrConversionCreateInfo & setYChromaOffset( vk::ChromaLocation yChromaOffset_ )
{
yChromaOffset = yChromaOffset_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setChromaFilter( Filter chromaFilter_ )
+ SamplerYcbcrConversionCreateInfo & setChromaFilter( vk::Filter chromaFilter_ )
{
chromaFilter = chromaFilter_;
return *this;
}
- SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
+ SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( vk::Bool32 forceExplicitReconstruction_ )
{
forceExplicitReconstruction = forceExplicitReconstruction_;
return *this;
@@ -46475,23 +60718,54 @@
}
private:
- StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo;
-
- public:
- const void* pNext = nullptr;
- Format format;
- SamplerYcbcrModelConversion ycbcrModel;
- SamplerYcbcrRange ycbcrRange;
- ComponentMapping components;
- ChromaLocation xChromaOffset;
- ChromaLocation yChromaOffset;
- Filter chromaFilter;
- Bool32 forceExplicitReconstruction;
+ using layout::SamplerYcbcrConversionCreateInfo::sType;
};
static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SamplerYcbcrConversionCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct SamplerYcbcrConversionImageFormatProperties
+ namespace layout
{
+ struct SamplerYcbcrConversionImageFormatProperties
+ {
+ protected:
+ SamplerYcbcrConversionImageFormatProperties()
+ {}
+
+ SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this) = rhs;
+ }
+
+ SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
+ void* pNext = nullptr;
+ uint32_t combinedImageSamplerDescriptorCount;
+ };
+ static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SamplerYcbcrConversionImageFormatProperties : public layout::SamplerYcbcrConversionImageFormatProperties
+ {
+ SamplerYcbcrConversionImageFormatProperties()
+ : layout::SamplerYcbcrConversionImageFormatProperties()
+ {}
+
+ SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs )
+ : layout::SamplerYcbcrConversionImageFormatProperties( rhs )
+ {}
+
+ SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs )
+ {
+ layout::SamplerYcbcrConversionImageFormatProperties::operator=(rhs);
+ return *this;
+ }
+
operator VkSamplerYcbcrConversionImageFormatProperties const&() const
{
return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>( this );
@@ -46515,28 +60789,52 @@
}
private:
- StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties;
-
- public:
- void* pNext = nullptr;
- uint32_t combinedImageSamplerDescriptorCount;
+ using layout::SamplerYcbcrConversionImageFormatProperties::sType;
};
static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SamplerYcbcrConversionImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
- struct SamplerYcbcrConversionInfo
+ namespace layout
{
- SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = SamplerYcbcrConversion() )
- : conversion( conversion_ )
+ struct SamplerYcbcrConversionInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() )
+ : conversion( conversion_ )
+ {}
+
+ SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs )
+ {
+ *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this) = rhs;
+ }
+
+ SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs )
+ {
+ *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
+ const void* pNext = nullptr;
+ vk::SamplerYcbcrConversion conversion;
+ };
+ static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SamplerYcbcrConversionInfo : public layout::SamplerYcbcrConversionInfo
+ {
+ VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() )
+ : layout::SamplerYcbcrConversionInfo( conversion_ )
{}
SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
- }
+ : layout::SamplerYcbcrConversionInfo( rhs )
+ {}
SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
+ layout::SamplerYcbcrConversionInfo::operator=(rhs);
return *this;
}
@@ -46546,7 +60844,7 @@
return *this;
}
- SamplerYcbcrConversionInfo & setConversion( SamplerYcbcrConversion conversion_ )
+ SamplerYcbcrConversionInfo & setConversion( vk::SamplerYcbcrConversion conversion_ )
{
conversion = conversion_;
return *this;
@@ -46575,28 +60873,52 @@
}
private:
- StructureType sType = StructureType::eSamplerYcbcrConversionInfo;
-
- public:
- const void* pNext = nullptr;
- SamplerYcbcrConversion conversion;
+ using layout::SamplerYcbcrConversionInfo::sType;
};
static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SamplerYcbcrConversionInfo>::value, "struct wrapper is not a standard layout!" );
- struct SemaphoreCreateInfo
+ namespace layout
{
- SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
- : flags( flags_ )
+ struct SemaphoreCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() )
+ : flags( flags_ )
+ {}
+
+ SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreCreateInfo*>(this) = rhs;
+ }
+
+ SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSemaphoreCreateInfo;
+ const void* pNext = nullptr;
+ vk::SemaphoreCreateFlags flags;
+ };
+ static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SemaphoreCreateInfo : public layout::SemaphoreCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() )
+ : layout::SemaphoreCreateInfo( flags_ )
{}
SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
- }
+ : layout::SemaphoreCreateInfo( rhs )
+ {}
SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
+ layout::SemaphoreCreateInfo::operator=(rhs);
return *this;
}
@@ -46606,7 +60928,7 @@
return *this;
}
- SemaphoreCreateInfo & setFlags( SemaphoreCreateFlags flags_ )
+ SemaphoreCreateInfo & setFlags( vk::SemaphoreCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -46635,30 +60957,56 @@
}
private:
- StructureType sType = StructureType::eSemaphoreCreateInfo;
-
- public:
- const void* pNext = nullptr;
- SemaphoreCreateFlags flags;
+ using layout::SemaphoreCreateInfo::sType;
};
static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct SemaphoreGetFdInfoKHR
+ namespace layout
{
- SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
- : semaphore( semaphore_ )
- , handleType( handleType_ )
+ struct SemaphoreGetFdInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : semaphore( semaphore_ )
+ , handleType( handleType_ )
+ {}
+
+ SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
+ }
+
+ SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
+ const void* pNext = nullptr;
+ vk::Semaphore semaphore;
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SemaphoreGetFdInfoKHR : public layout::SemaphoreGetFdInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : layout::SemaphoreGetFdInfoKHR( semaphore_, handleType_ )
{}
SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
- }
+ : layout::SemaphoreGetFdInfoKHR( rhs )
+ {}
SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
+ layout::SemaphoreGetFdInfoKHR::operator=(rhs);
return *this;
}
@@ -46668,13 +61016,13 @@
return *this;
}
- SemaphoreGetFdInfoKHR & setSemaphore( Semaphore semaphore_ )
+ SemaphoreGetFdInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
{
semaphore = semaphore_;
return *this;
}
- SemaphoreGetFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ SemaphoreGetFdInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -46704,32 +61052,58 @@
}
private:
- StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Semaphore semaphore;
- ExternalSemaphoreHandleTypeFlagBits handleType;
+ using layout::SemaphoreGetFdInfoKHR::sType;
};
static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SemaphoreGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct SemaphoreGetWin32HandleInfoKHR
+
+ namespace layout
{
- SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
- ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
- : semaphore( semaphore_ )
- , handleType( handleType_ )
+ struct SemaphoreGetWin32HandleInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : semaphore( semaphore_ )
+ , handleType( handleType_ )
+ {}
+
+ SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
+ }
+
+ SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
+ const void* pNext = nullptr;
+ vk::Semaphore semaphore;
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType;
+ };
+ static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SemaphoreGetWin32HandleInfoKHR : public layout::SemaphoreGetWin32HandleInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
+ : layout::SemaphoreGetWin32HandleInfoKHR( semaphore_, handleType_ )
{}
SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
- }
+ : layout::SemaphoreGetWin32HandleInfoKHR( rhs )
+ {}
SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
+ layout::SemaphoreGetWin32HandleInfoKHR::operator=(rhs);
return *this;
}
@@ -46739,13 +61113,13 @@
return *this;
}
- SemaphoreGetWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ )
+ SemaphoreGetWin32HandleInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
{
semaphore = semaphore_;
return *this;
}
- SemaphoreGetWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
+ SemaphoreGetWin32HandleInfoKHR & setHandleType( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ )
{
handleType = handleType_;
return *this;
@@ -46775,34 +61149,368 @@
}
private:
- StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Semaphore semaphore;
- ExternalSemaphoreHandleTypeFlagBits handleType;
+ using layout::SemaphoreGetWin32HandleInfoKHR::sType;
};
static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SemaphoreGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct ShaderModuleCreateInfo
+ namespace layout
{
- ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(),
- size_t codeSize_ = 0,
- const uint32_t* pCode_ = nullptr )
- : flags( flags_ )
- , codeSize( codeSize_ )
- , pCode( pCode_ )
+ struct SemaphoreSignalInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ uint64_t value_ = 0 )
+ : semaphore( semaphore_ )
+ , value( value_ )
+ {}
+
+ SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreSignalInfoKHR*>(this) = rhs;
+ }
+
+ SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreSignalInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR;
+ const void* pNext = nullptr;
+ vk::Semaphore semaphore;
+ uint64_t value;
+ };
+ static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SemaphoreSignalInfoKHR : public layout::SemaphoreSignalInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(),
+ uint64_t value_ = 0 )
+ : layout::SemaphoreSignalInfoKHR( semaphore_, value_ )
+ {}
+
+ SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs )
+ : layout::SemaphoreSignalInfoKHR( rhs )
+ {}
+
+ SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs )
+ {
+ layout::SemaphoreSignalInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ SemaphoreSignalInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ SemaphoreSignalInfoKHR & setSemaphore( vk::Semaphore semaphore_ )
+ {
+ semaphore = semaphore_;
+ return *this;
+ }
+
+ SemaphoreSignalInfoKHR & setValue( uint64_t value_ )
+ {
+ value = value_;
+ return *this;
+ }
+
+ operator VkSemaphoreSignalInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkSemaphoreSignalInfoKHR*>( this );
+ }
+
+ operator VkSemaphoreSignalInfoKHR &()
+ {
+ return *reinterpret_cast<VkSemaphoreSignalInfoKHR*>( this );
+ }
+
+ bool operator==( SemaphoreSignalInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( semaphore == rhs.semaphore )
+ && ( value == rhs.value );
+ }
+
+ bool operator!=( SemaphoreSignalInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::SemaphoreSignalInfoKHR::sType;
+ };
+ static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SemaphoreSignalInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct SemaphoreTypeCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary,
+ uint64_t initialValue_ = 0 )
+ : semaphoreType( semaphoreType_ )
+ , initialValue( initialValue_ )
+ {}
+
+ SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreTypeCreateInfoKHR*>(this) = rhs;
+ }
+
+ SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreTypeCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::SemaphoreTypeKHR semaphoreType;
+ uint64_t initialValue;
+ };
+ static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SemaphoreTypeCreateInfoKHR : public layout::SemaphoreTypeCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary,
+ uint64_t initialValue_ = 0 )
+ : layout::SemaphoreTypeCreateInfoKHR( semaphoreType_, initialValue_ )
+ {}
+
+ SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs )
+ : layout::SemaphoreTypeCreateInfoKHR( rhs )
+ {}
+
+ SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs )
+ {
+ layout::SemaphoreTypeCreateInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ SemaphoreTypeCreateInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ SemaphoreTypeCreateInfoKHR & setSemaphoreType( vk::SemaphoreTypeKHR semaphoreType_ )
+ {
+ semaphoreType = semaphoreType_;
+ return *this;
+ }
+
+ SemaphoreTypeCreateInfoKHR & setInitialValue( uint64_t initialValue_ )
+ {
+ initialValue = initialValue_;
+ return *this;
+ }
+
+ operator VkSemaphoreTypeCreateInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkSemaphoreTypeCreateInfoKHR*>( this );
+ }
+
+ operator VkSemaphoreTypeCreateInfoKHR &()
+ {
+ return *reinterpret_cast<VkSemaphoreTypeCreateInfoKHR*>( this );
+ }
+
+ bool operator==( SemaphoreTypeCreateInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( semaphoreType == rhs.semaphoreType )
+ && ( initialValue == rhs.initialValue );
+ }
+
+ bool operator!=( SemaphoreTypeCreateInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::SemaphoreTypeCreateInfoKHR::sType;
+ };
+ static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SemaphoreTypeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct SemaphoreWaitInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(),
+ uint32_t semaphoreCount_ = 0,
+ const vk::Semaphore* pSemaphores_ = nullptr,
+ const uint64_t* pValues_ = nullptr )
+ : flags( flags_ )
+ , semaphoreCount( semaphoreCount_ )
+ , pSemaphores( pSemaphores_ )
+ , pValues( pValues_ )
+ {}
+
+ SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreWaitInfoKHR*>(this) = rhs;
+ }
+
+ SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSemaphoreWaitInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR;
+ const void* pNext = nullptr;
+ vk::SemaphoreWaitFlagsKHR flags;
+ uint32_t semaphoreCount;
+ const vk::Semaphore* pSemaphores;
+ const uint64_t* pValues;
+ };
+ static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SemaphoreWaitInfoKHR : public layout::SemaphoreWaitInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(),
+ uint32_t semaphoreCount_ = 0,
+ const vk::Semaphore* pSemaphores_ = nullptr,
+ const uint64_t* pValues_ = nullptr )
+ : layout::SemaphoreWaitInfoKHR( flags_, semaphoreCount_, pSemaphores_, pValues_ )
+ {}
+
+ SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs )
+ : layout::SemaphoreWaitInfoKHR( rhs )
+ {}
+
+ SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs )
+ {
+ layout::SemaphoreWaitInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ SemaphoreWaitInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ SemaphoreWaitInfoKHR & setFlags( vk::SemaphoreWaitFlagsKHR flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ SemaphoreWaitInfoKHR & setSemaphoreCount( uint32_t semaphoreCount_ )
+ {
+ semaphoreCount = semaphoreCount_;
+ return *this;
+ }
+
+ SemaphoreWaitInfoKHR & setPSemaphores( const vk::Semaphore* pSemaphores_ )
+ {
+ pSemaphores = pSemaphores_;
+ return *this;
+ }
+
+ SemaphoreWaitInfoKHR & setPValues( const uint64_t* pValues_ )
+ {
+ pValues = pValues_;
+ return *this;
+ }
+
+ operator VkSemaphoreWaitInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkSemaphoreWaitInfoKHR*>( this );
+ }
+
+ operator VkSemaphoreWaitInfoKHR &()
+ {
+ return *reinterpret_cast<VkSemaphoreWaitInfoKHR*>( this );
+ }
+
+ bool operator==( SemaphoreWaitInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( semaphoreCount == rhs.semaphoreCount )
+ && ( pSemaphores == rhs.pSemaphores )
+ && ( pValues == rhs.pValues );
+ }
+
+ bool operator!=( SemaphoreWaitInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::SemaphoreWaitInfoKHR::sType;
+ };
+ static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SemaphoreWaitInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct ShaderModuleCreateInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(),
+ size_t codeSize_ = 0,
+ const uint32_t* pCode_ = nullptr )
+ : flags( flags_ )
+ , codeSize( codeSize_ )
+ , pCode( pCode_ )
+ {}
+
+ ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkShaderModuleCreateInfo*>(this) = rhs;
+ }
+
+ ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
+ {
+ *reinterpret_cast<VkShaderModuleCreateInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eShaderModuleCreateInfo;
+ const void* pNext = nullptr;
+ vk::ShaderModuleCreateFlags flags;
+ size_t codeSize;
+ const uint32_t* pCode;
+ };
+ static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ShaderModuleCreateInfo : public layout::ShaderModuleCreateInfo
+ {
+ VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(),
+ size_t codeSize_ = 0,
+ const uint32_t* pCode_ = nullptr )
+ : layout::ShaderModuleCreateInfo( flags_, codeSize_, pCode_ )
{}
ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
- }
+ : layout::ShaderModuleCreateInfo( rhs )
+ {}
ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
+ layout::ShaderModuleCreateInfo::operator=(rhs);
return *this;
}
@@ -46812,7 +61520,7 @@
return *this;
}
- ShaderModuleCreateInfo & setFlags( ShaderModuleCreateFlags flags_ )
+ ShaderModuleCreateInfo & setFlags( vk::ShaderModuleCreateFlags flags_ )
{
flags = flags_;
return *this;
@@ -46855,30 +61563,52 @@
}
private:
- StructureType sType = StructureType::eShaderModuleCreateInfo;
-
- public:
- const void* pNext = nullptr;
- ShaderModuleCreateFlags flags;
- size_t codeSize;
- const uint32_t* pCode;
+ using layout::ShaderModuleCreateInfo::sType;
};
static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ShaderModuleCreateInfo>::value, "struct wrapper is not a standard layout!" );
- struct ShaderModuleValidationCacheCreateInfoEXT
+ namespace layout
{
- ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
- : validationCache( validationCache_ )
+ struct ShaderModuleValidationCacheCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() )
+ : validationCache( validationCache_ )
+ {}
+
+ ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
+ }
+
+ ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::ValidationCacheEXT validationCache;
+ };
+ static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ShaderModuleValidationCacheCreateInfoEXT : public layout::ShaderModuleValidationCacheCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() )
+ : layout::ShaderModuleValidationCacheCreateInfoEXT( validationCache_ )
{}
ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
- }
+ : layout::ShaderModuleValidationCacheCreateInfoEXT( rhs )
+ {}
ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
+ layout::ShaderModuleValidationCacheCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -46888,7 +61618,7 @@
return *this;
}
- ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( ValidationCacheEXT validationCache_ )
+ ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( vk::ValidationCacheEXT validationCache_ )
{
validationCache = validationCache_;
return *this;
@@ -46917,16 +61647,27 @@
}
private:
- StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- ValidationCacheEXT validationCache;
+ using layout::ShaderModuleValidationCacheCreateInfoEXT::sType;
};
static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ShaderModuleValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
struct ShaderResourceUsageAMD
{
+ ShaderResourceUsageAMD()
+ {}
+
+ ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs )
+ {
+ *reinterpret_cast<VkShaderResourceUsageAMD*>(this) = rhs;
+ }
+
+ ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs )
+ {
+ *reinterpret_cast<VkShaderResourceUsageAMD*>(this) = rhs;
+ return *this;
+ }
+
operator VkShaderResourceUsageAMD const&() const
{
return *reinterpret_cast<const VkShaderResourceUsageAMD*>( this );
@@ -46951,6 +61692,7 @@
return !operator==( rhs );
}
+ public:
uint32_t numUsedVgprs;
uint32_t numUsedSgprs;
uint32_t ldsSizePerLocalWorkGroup;
@@ -46958,9 +61700,24 @@
size_t scratchMemUsageInBytes;
};
static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ShaderResourceUsageAMD>::value, "struct wrapper is not a standard layout!" );
struct ShaderStatisticsInfoAMD
{
+ ShaderStatisticsInfoAMD()
+ {}
+
+ ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this) = rhs;
+ }
+
+ ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this) = rhs;
+ return *this;
+ }
+
operator VkShaderStatisticsInfoAMD const&() const
{
return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>( this );
@@ -46987,8 +61744,9 @@
return !operator==( rhs );
}
- ShaderStageFlags shaderStageMask;
- ShaderResourceUsageAMD resourceUsage;
+ public:
+ vk::ShaderStageFlags shaderStageMask;
+ vk::ShaderResourceUsageAMD resourceUsage;
uint32_t numPhysicalVgprs;
uint32_t numPhysicalSgprs;
uint32_t numAvailableVgprs;
@@ -46996,9 +61754,51 @@
uint32_t computeWorkGroupSize[3];
};
static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ShaderStatisticsInfoAMD>::value, "struct wrapper is not a standard layout!" );
- struct SharedPresentSurfaceCapabilitiesKHR
+ namespace layout
{
+ struct SharedPresentSurfaceCapabilitiesKHR
+ {
+ protected:
+ SharedPresentSurfaceCapabilitiesKHR()
+ {}
+
+ SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this) = rhs;
+ }
+
+ SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
+ void* pNext = nullptr;
+ vk::ImageUsageFlags sharedPresentSupportedUsageFlags;
+ };
+ static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SharedPresentSurfaceCapabilitiesKHR : public layout::SharedPresentSurfaceCapabilitiesKHR
+ {
+ SharedPresentSurfaceCapabilitiesKHR()
+ : layout::SharedPresentSurfaceCapabilitiesKHR()
+ {}
+
+ SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
+ : layout::SharedPresentSurfaceCapabilitiesKHR( rhs )
+ {}
+
+ SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs )
+ {
+ layout::SharedPresentSurfaceCapabilitiesKHR::operator=(rhs);
+ return *this;
+ }
+
operator VkSharedPresentSurfaceCapabilitiesKHR const&() const
{
return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>( this );
@@ -47022,16 +61822,27 @@
}
private:
- StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
-
- public:
- void* pNext = nullptr;
- ImageUsageFlags sharedPresentSupportedUsageFlags;
+ using layout::SharedPresentSurfaceCapabilitiesKHR::sType;
};
static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SharedPresentSurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
struct SparseImageFormatProperties
{
+ SparseImageFormatProperties()
+ {}
+
+ SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageFormatProperties*>(this) = rhs;
+ }
+
+ SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageFormatProperties*>(this) = rhs;
+ return *this;
+ }
+
operator VkSparseImageFormatProperties const&() const
{
return *reinterpret_cast<const VkSparseImageFormatProperties*>( this );
@@ -47054,14 +61865,57 @@
return !operator==( rhs );
}
- ImageAspectFlags aspectMask;
- Extent3D imageGranularity;
- SparseImageFormatFlags flags;
+ public:
+ vk::ImageAspectFlags aspectMask;
+ vk::Extent3D imageGranularity;
+ vk::SparseImageFormatFlags flags;
};
static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
- struct SparseImageFormatProperties2
+ namespace layout
{
+ struct SparseImageFormatProperties2
+ {
+ protected:
+ SparseImageFormatProperties2()
+ {}
+
+ SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageFormatProperties2*>(this) = rhs;
+ }
+
+ SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageFormatProperties2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSparseImageFormatProperties2;
+ void* pNext = nullptr;
+ vk::SparseImageFormatProperties properties;
+ };
+ static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SparseImageFormatProperties2 : public layout::SparseImageFormatProperties2
+ {
+ SparseImageFormatProperties2()
+ : layout::SparseImageFormatProperties2()
+ {}
+
+ SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs )
+ : layout::SparseImageFormatProperties2( rhs )
+ {}
+
+ SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs )
+ {
+ layout::SparseImageFormatProperties2::operator=(rhs);
+ return *this;
+ }
+
operator VkSparseImageFormatProperties2 const&() const
{
return *reinterpret_cast<const VkSparseImageFormatProperties2*>( this );
@@ -47085,16 +61939,27 @@
}
private:
- StructureType sType = StructureType::eSparseImageFormatProperties2;
-
- public:
- void* pNext = nullptr;
- SparseImageFormatProperties properties;
+ using layout::SparseImageFormatProperties2::sType;
};
static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
struct SparseImageMemoryRequirements
{
+ SparseImageMemoryRequirements()
+ {}
+
+ SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageMemoryRequirements*>(this) = rhs;
+ }
+
+ SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageMemoryRequirements*>(this) = rhs;
+ return *this;
+ }
+
operator VkSparseImageMemoryRequirements const&() const
{
return *reinterpret_cast<const VkSparseImageMemoryRequirements*>( this );
@@ -47119,16 +61984,59 @@
return !operator==( rhs );
}
- SparseImageFormatProperties formatProperties;
+ public:
+ vk::SparseImageFormatProperties formatProperties;
uint32_t imageMipTailFirstLod;
- DeviceSize imageMipTailSize;
- DeviceSize imageMipTailOffset;
- DeviceSize imageMipTailStride;
+ vk::DeviceSize imageMipTailSize;
+ vk::DeviceSize imageMipTailOffset;
+ vk::DeviceSize imageMipTailStride;
};
static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageMemoryRequirements>::value, "struct wrapper is not a standard layout!" );
- struct SparseImageMemoryRequirements2
+ namespace layout
{
+ struct SparseImageMemoryRequirements2
+ {
+ protected:
+ SparseImageMemoryRequirements2()
+ {}
+
+ SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this) = rhs;
+ }
+
+ SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs )
+ {
+ *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2;
+ void* pNext = nullptr;
+ vk::SparseImageMemoryRequirements memoryRequirements;
+ };
+ static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SparseImageMemoryRequirements2 : public layout::SparseImageMemoryRequirements2
+ {
+ SparseImageMemoryRequirements2()
+ : layout::SparseImageMemoryRequirements2()
+ {}
+
+ SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs )
+ : layout::SparseImageMemoryRequirements2( rhs )
+ {}
+
+ SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs )
+ {
+ layout::SparseImageMemoryRequirements2::operator=(rhs);
+ return *this;
+ }
+
operator VkSparseImageMemoryRequirements2 const&() const
{
return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>( this );
@@ -47152,31 +62060,58 @@
}
private:
- StructureType sType = StructureType::eSparseImageMemoryRequirements2;
-
- public:
- void* pNext = nullptr;
- SparseImageMemoryRequirements memoryRequirements;
+ using layout::SparseImageMemoryRequirements2::sType;
};
static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SparseImageMemoryRequirements2>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_GGP
- struct StreamDescriptorSurfaceCreateInfoGGP
+
+ namespace layout
{
- StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateFlagsGGP flags_ = StreamDescriptorSurfaceCreateFlagsGGP(),
- GgpStreamDescriptor streamDescriptor_ = 0 )
- : flags( flags_ )
- , streamDescriptor( streamDescriptor_ )
+ struct StreamDescriptorSurfaceCreateInfoGGP
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(),
+ GgpStreamDescriptor streamDescriptor_ = 0 )
+ : flags( flags_ )
+ , streamDescriptor( streamDescriptor_ )
+ {}
+
+ StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
+ {
+ *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
+ }
+
+ StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
+ {
+ *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
+ const void* pNext = nullptr;
+ vk::StreamDescriptorSurfaceCreateFlagsGGP flags;
+ GgpStreamDescriptor streamDescriptor;
+ };
+ static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "layout struct and wrapper have different size!" );
+ }
+
+ struct StreamDescriptorSurfaceCreateInfoGGP : public layout::StreamDescriptorSurfaceCreateInfoGGP
+ {
+ VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(),
+ GgpStreamDescriptor streamDescriptor_ = 0 )
+ : layout::StreamDescriptorSurfaceCreateInfoGGP( flags_, streamDescriptor_ )
{}
StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
- {
- memcpy( this, &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) );
- }
+ : layout::StreamDescriptorSurfaceCreateInfoGGP( rhs )
+ {}
StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs )
{
- memcpy( this, &rhs, sizeof( StreamDescriptorSurfaceCreateInfoGGP ) );
+ layout::StreamDescriptorSurfaceCreateInfoGGP::operator=(rhs);
return *this;
}
@@ -47186,7 +62121,7 @@
return *this;
}
- StreamDescriptorSurfaceCreateInfoGGP & setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ )
+ StreamDescriptorSurfaceCreateInfoGGP & setFlags( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ )
{
flags = flags_;
return *this;
@@ -47222,42 +62157,77 @@
}
private:
- StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP;
-
- public:
- const void* pNext = nullptr;
- StreamDescriptorSurfaceCreateFlagsGGP flags;
- GgpStreamDescriptor streamDescriptor;
+ using layout::StreamDescriptorSurfaceCreateInfoGGP::sType;
};
static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<StreamDescriptorSurfaceCreateInfoGGP>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_GGP*/
- struct SubmitInfo
+ namespace layout
{
- 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 )
- : waitSemaphoreCount( waitSemaphoreCount_ )
- , pWaitSemaphores( pWaitSemaphores_ )
- , pWaitDstStageMask( pWaitDstStageMask_ )
- , commandBufferCount( commandBufferCount_ )
- , pCommandBuffers( pCommandBuffers_ )
- , signalSemaphoreCount( signalSemaphoreCount_ )
- , pSignalSemaphores( pSignalSemaphores_ )
+ struct SubmitInfo
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+ const vk::Semaphore* pWaitSemaphores_ = nullptr,
+ const vk::PipelineStageFlags* pWaitDstStageMask_ = nullptr,
+ uint32_t commandBufferCount_ = 0,
+ const vk::CommandBuffer* pCommandBuffers_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const vk::Semaphore* pSignalSemaphores_ = nullptr )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
+ , pWaitSemaphores( pWaitSemaphores_ )
+ , pWaitDstStageMask( pWaitDstStageMask_ )
+ , commandBufferCount( commandBufferCount_ )
+ , pCommandBuffers( pCommandBuffers_ )
+ , signalSemaphoreCount( signalSemaphoreCount_ )
+ , pSignalSemaphores( pSignalSemaphores_ )
+ {}
+
+ SubmitInfo( VkSubmitInfo const & rhs )
+ {
+ *reinterpret_cast<VkSubmitInfo*>(this) = rhs;
+ }
+
+ SubmitInfo& operator=( VkSubmitInfo const & rhs )
+ {
+ *reinterpret_cast<VkSubmitInfo*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSubmitInfo;
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreCount;
+ const vk::Semaphore* pWaitSemaphores;
+ const vk::PipelineStageFlags* pWaitDstStageMask;
+ uint32_t commandBufferCount;
+ const vk::CommandBuffer* pCommandBuffers;
+ uint32_t signalSemaphoreCount;
+ const vk::Semaphore* pSignalSemaphores;
+ };
+ static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SubmitInfo : public layout::SubmitInfo
+ {
+ VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
+ const vk::Semaphore* pWaitSemaphores_ = nullptr,
+ const vk::PipelineStageFlags* pWaitDstStageMask_ = nullptr,
+ uint32_t commandBufferCount_ = 0,
+ const vk::CommandBuffer* pCommandBuffers_ = nullptr,
+ uint32_t signalSemaphoreCount_ = 0,
+ const vk::Semaphore* pSignalSemaphores_ = nullptr )
+ : layout::SubmitInfo( waitSemaphoreCount_, pWaitSemaphores_, pWaitDstStageMask_, commandBufferCount_, pCommandBuffers_, signalSemaphoreCount_, pSignalSemaphores_ )
{}
SubmitInfo( VkSubmitInfo const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubmitInfo ) );
- }
+ : layout::SubmitInfo( rhs )
+ {}
SubmitInfo& operator=( VkSubmitInfo const & rhs )
{
- memcpy( this, &rhs, sizeof( SubmitInfo ) );
+ layout::SubmitInfo::operator=(rhs);
return *this;
}
@@ -47273,13 +62243,13 @@
return *this;
}
- SubmitInfo & setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
+ SubmitInfo & setPWaitSemaphores( const vk::Semaphore* pWaitSemaphores_ )
{
pWaitSemaphores = pWaitSemaphores_;
return *this;
}
- SubmitInfo & setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ )
+ SubmitInfo & setPWaitDstStageMask( const vk::PipelineStageFlags* pWaitDstStageMask_ )
{
pWaitDstStageMask = pWaitDstStageMask_;
return *this;
@@ -47291,7 +62261,7 @@
return *this;
}
- SubmitInfo & setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
+ SubmitInfo & setPCommandBuffers( const vk::CommandBuffer* pCommandBuffers_ )
{
pCommandBuffers = pCommandBuffers_;
return *this;
@@ -47303,7 +62273,7 @@
return *this;
}
- SubmitInfo & setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
+ SubmitInfo & setPSignalSemaphores( const vk::Semaphore* pSignalSemaphores_ )
{
pSignalSemaphores = pSignalSemaphores_;
return *this;
@@ -47338,34 +62308,52 @@
}
private:
- StructureType sType = StructureType::eSubmitInfo;
-
- public:
- const void* pNext = nullptr;
- uint32_t waitSemaphoreCount;
- const Semaphore* pWaitSemaphores;
- const PipelineStageFlags* pWaitDstStageMask;
- uint32_t commandBufferCount;
- const CommandBuffer* pCommandBuffers;
- uint32_t signalSemaphoreCount;
- const Semaphore* pSignalSemaphores;
+ using layout::SubmitInfo::sType;
};
static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubmitInfo>::value, "struct wrapper is not a standard layout!" );
- struct SubpassBeginInfoKHR
+ namespace layout
{
- SubpassBeginInfoKHR( SubpassContents contents_ = SubpassContents::eInline )
- : contents( contents_ )
+ struct SubpassBeginInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline )
+ : contents( contents_ )
+ {}
+
+ SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassBeginInfoKHR*>(this) = rhs;
+ }
+
+ SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassBeginInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSubpassBeginInfoKHR;
+ const void* pNext = nullptr;
+ vk::SubpassContents contents;
+ };
+ static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SubpassBeginInfoKHR : public layout::SubpassBeginInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline )
+ : layout::SubpassBeginInfoKHR( contents_ )
{}
SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
- }
+ : layout::SubpassBeginInfoKHR( rhs )
+ {}
SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
+ layout::SubpassBeginInfoKHR::operator=(rhs);
return *this;
}
@@ -47375,7 +62363,7 @@
return *this;
}
- SubpassBeginInfoKHR & setContents( SubpassContents contents_ )
+ SubpassBeginInfoKHR & setContents( vk::SubpassContents contents_ )
{
contents = contents_;
return *this;
@@ -47404,32 +62392,60 @@
}
private:
- StructureType sType = StructureType::eSubpassBeginInfoKHR;
-
- public:
- const void* pNext = nullptr;
- SubpassContents contents;
+ using layout::SubpassBeginInfoKHR::sType;
};
static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassBeginInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct SubpassDescriptionDepthStencilResolveKHR
+ namespace layout
{
- SubpassDescriptionDepthStencilResolveKHR( ResolveModeFlagBitsKHR depthResolveMode_ = ResolveModeFlagBitsKHR::eNone,
- ResolveModeFlagBitsKHR stencilResolveMode_ = ResolveModeFlagBitsKHR::eNone,
- const AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
- : depthResolveMode( depthResolveMode_ )
- , stencilResolveMode( stencilResolveMode_ )
- , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
+ struct SubpassDescriptionDepthStencilResolveKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+ vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+ const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
+ : depthResolveMode( depthResolveMode_ )
+ , stencilResolveMode( stencilResolveMode_ )
+ , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ )
+ {}
+
+ SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
+ }
+
+ SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR;
+ const void* pNext = nullptr;
+ vk::ResolveModeFlagBitsKHR depthResolveMode;
+ vk::ResolveModeFlagBitsKHR stencilResolveMode;
+ const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment;
+ };
+ static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SubpassDescriptionDepthStencilResolveKHR : public layout::SubpassDescriptionDepthStencilResolveKHR
+ {
+ VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+ vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone,
+ const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr )
+ : layout::SubpassDescriptionDepthStencilResolveKHR( depthResolveMode_, stencilResolveMode_, pDepthStencilResolveAttachment_ )
{}
SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassDescriptionDepthStencilResolveKHR ) );
- }
+ : layout::SubpassDescriptionDepthStencilResolveKHR( rhs )
+ {}
SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassDescriptionDepthStencilResolveKHR ) );
+ layout::SubpassDescriptionDepthStencilResolveKHR::operator=(rhs);
return *this;
}
@@ -47439,19 +62455,19 @@
return *this;
}
- SubpassDescriptionDepthStencilResolveKHR & setDepthResolveMode( ResolveModeFlagBitsKHR depthResolveMode_ )
+ SubpassDescriptionDepthStencilResolveKHR & setDepthResolveMode( vk::ResolveModeFlagBitsKHR depthResolveMode_ )
{
depthResolveMode = depthResolveMode_;
return *this;
}
- SubpassDescriptionDepthStencilResolveKHR & setStencilResolveMode( ResolveModeFlagBitsKHR stencilResolveMode_ )
+ SubpassDescriptionDepthStencilResolveKHR & setStencilResolveMode( vk::ResolveModeFlagBitsKHR stencilResolveMode_ )
{
stencilResolveMode = stencilResolveMode_;
return *this;
}
- SubpassDescriptionDepthStencilResolveKHR & setPDepthStencilResolveAttachment( const AttachmentReference2KHR* pDepthStencilResolveAttachment_ )
+ SubpassDescriptionDepthStencilResolveKHR & setPDepthStencilResolveAttachment( const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ )
{
pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_;
return *this;
@@ -47482,29 +62498,50 @@
}
private:
- StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR;
-
- public:
- const void* pNext = nullptr;
- ResolveModeFlagBitsKHR depthResolveMode;
- ResolveModeFlagBitsKHR stencilResolveMode;
- const AttachmentReference2KHR* pDepthStencilResolveAttachment;
+ using layout::SubpassDescriptionDepthStencilResolveKHR::sType;
};
static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassDescriptionDepthStencilResolveKHR>::value, "struct wrapper is not a standard layout!" );
- struct SubpassEndInfoKHR
+ namespace layout
{
- SubpassEndInfoKHR( )
+ struct SubpassEndInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR()
+ {}
+
+ SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassEndInfoKHR*>(this) = rhs;
+ }
+
+ SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSubpassEndInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSubpassEndInfoKHR;
+ const void* pNext = nullptr;
+ };
+ static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SubpassEndInfoKHR : public layout::SubpassEndInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR()
+ : layout::SubpassEndInfoKHR()
{}
SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
- }
+ : layout::SubpassEndInfoKHR( rhs )
+ {}
SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
+ layout::SubpassEndInfoKHR::operator=(rhs);
return *this;
}
@@ -47536,15 +62573,64 @@
}
private:
- StructureType sType = StructureType::eSubpassEndInfoKHR;
-
- public:
- const void* pNext = nullptr;
+ using layout::SubpassEndInfoKHR::sType;
};
static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SubpassEndInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct SurfaceCapabilities2EXT
+ namespace layout
{
+ struct SurfaceCapabilities2EXT
+ {
+ protected:
+ SurfaceCapabilities2EXT()
+ {}
+
+ SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this) = rhs;
+ }
+
+ SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceCapabilities2EXT;
+ void* pNext = nullptr;
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ vk::Extent2D currentExtent;
+ vk::Extent2D minImageExtent;
+ vk::Extent2D maxImageExtent;
+ uint32_t maxImageArrayLayers;
+ vk::SurfaceTransformFlagsKHR supportedTransforms;
+ vk::SurfaceTransformFlagBitsKHR currentTransform;
+ vk::CompositeAlphaFlagsKHR supportedCompositeAlpha;
+ vk::ImageUsageFlags supportedUsageFlags;
+ vk::SurfaceCounterFlagsEXT supportedSurfaceCounters;
+ };
+ static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceCapabilities2EXT : public layout::SurfaceCapabilities2EXT
+ {
+ SurfaceCapabilities2EXT()
+ : layout::SurfaceCapabilities2EXT()
+ {}
+
+ SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs )
+ : layout::SurfaceCapabilities2EXT( rhs )
+ {}
+
+ SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs )
+ {
+ layout::SurfaceCapabilities2EXT::operator=(rhs);
+ return *this;
+ }
+
operator VkSurfaceCapabilities2EXT const&() const
{
return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>( this );
@@ -47578,26 +62664,27 @@
}
private:
- StructureType sType = StructureType::eSurfaceCapabilities2EXT;
-
- public:
- void* pNext = nullptr;
- uint32_t minImageCount;
- uint32_t maxImageCount;
- Extent2D currentExtent;
- Extent2D minImageExtent;
- Extent2D maxImageExtent;
- uint32_t maxImageArrayLayers;
- SurfaceTransformFlagsKHR supportedTransforms;
- SurfaceTransformFlagBitsKHR currentTransform;
- CompositeAlphaFlagsKHR supportedCompositeAlpha;
- ImageUsageFlags supportedUsageFlags;
- SurfaceCounterFlagsEXT supportedSurfaceCounters;
+ using layout::SurfaceCapabilities2EXT::sType;
};
static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceCapabilities2EXT>::value, "struct wrapper is not a standard layout!" );
struct SurfaceCapabilitiesKHR
{
+ SurfaceCapabilitiesKHR()
+ {}
+
+ SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this) = rhs;
+ }
+
+ SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this) = rhs;
+ return *this;
+ }
+
operator VkSurfaceCapabilitiesKHR const&() const
{
return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>( this );
@@ -47627,21 +62714,64 @@
return !operator==( rhs );
}
+ public:
uint32_t minImageCount;
uint32_t maxImageCount;
- Extent2D currentExtent;
- Extent2D minImageExtent;
- Extent2D maxImageExtent;
+ vk::Extent2D currentExtent;
+ vk::Extent2D minImageExtent;
+ vk::Extent2D maxImageExtent;
uint32_t maxImageArrayLayers;
- SurfaceTransformFlagsKHR supportedTransforms;
- SurfaceTransformFlagBitsKHR currentTransform;
- CompositeAlphaFlagsKHR supportedCompositeAlpha;
- ImageUsageFlags supportedUsageFlags;
+ vk::SurfaceTransformFlagsKHR supportedTransforms;
+ vk::SurfaceTransformFlagBitsKHR currentTransform;
+ vk::CompositeAlphaFlagsKHR supportedCompositeAlpha;
+ vk::ImageUsageFlags supportedUsageFlags;
};
static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct SurfaceCapabilities2KHR
+ namespace layout
{
+ struct SurfaceCapabilities2KHR
+ {
+ protected:
+ SurfaceCapabilities2KHR()
+ {}
+
+ SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
+ }
+
+ SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR;
+ void* pNext = nullptr;
+ vk::SurfaceCapabilitiesKHR surfaceCapabilities;
+ };
+ static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceCapabilities2KHR : public layout::SurfaceCapabilities2KHR
+ {
+ SurfaceCapabilities2KHR()
+ : layout::SurfaceCapabilities2KHR()
+ {}
+
+ SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs )
+ : layout::SurfaceCapabilities2KHR( rhs )
+ {}
+
+ SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs )
+ {
+ layout::SurfaceCapabilities2KHR::operator=(rhs);
+ return *this;
+ }
+
operator VkSurfaceCapabilities2KHR const&() const
{
return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>( this );
@@ -47665,29 +62795,54 @@
}
private:
- StructureType sType = StructureType::eSurfaceCapabilities2KHR;
-
- public:
- void* pNext = nullptr;
- SurfaceCapabilitiesKHR surfaceCapabilities;
+ using layout::SurfaceCapabilities2KHR::sType;
};
static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceCapabilities2KHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct SurfaceCapabilitiesFullScreenExclusiveEXT
+
+ namespace layout
{
- SurfaceCapabilitiesFullScreenExclusiveEXT( Bool32 fullScreenExclusiveSupported_ = 0 )
- : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
+ struct SurfaceCapabilitiesFullScreenExclusiveEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 )
+ : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ )
+ {}
+
+ SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
+ }
+
+ SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
+ void* pNext = nullptr;
+ vk::Bool32 fullScreenExclusiveSupported;
+ };
+ static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceCapabilitiesFullScreenExclusiveEXT : public layout::SurfaceCapabilitiesFullScreenExclusiveEXT
+ {
+ VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 )
+ : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( fullScreenExclusiveSupported_ )
{}
SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) );
- }
+ : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( rhs )
+ {}
SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) );
+ layout::SurfaceCapabilitiesFullScreenExclusiveEXT::operator=(rhs);
return *this;
}
@@ -47697,7 +62852,7 @@
return *this;
}
- SurfaceCapabilitiesFullScreenExclusiveEXT & setFullScreenExclusiveSupported( Bool32 fullScreenExclusiveSupported_ )
+ SurfaceCapabilitiesFullScreenExclusiveEXT & setFullScreenExclusiveSupported( vk::Bool32 fullScreenExclusiveSupported_ )
{
fullScreenExclusiveSupported = fullScreenExclusiveSupported_;
return *this;
@@ -47726,17 +62881,28 @@
}
private:
- StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT;
-
- public:
- void* pNext = nullptr;
- Bool32 fullScreenExclusiveSupported;
+ using layout::SurfaceCapabilitiesFullScreenExclusiveEXT::sType;
};
static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceCapabilitiesFullScreenExclusiveEXT>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
struct SurfaceFormatKHR
{
+ SurfaceFormatKHR()
+ {}
+
+ SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFormatKHR*>(this) = rhs;
+ }
+
+ SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFormatKHR*>(this) = rhs;
+ return *this;
+ }
+
operator VkSurfaceFormatKHR const&() const
{
return *reinterpret_cast<const VkSurfaceFormatKHR*>( this );
@@ -47758,13 +62924,56 @@
return !operator==( rhs );
}
- Format format;
- ColorSpaceKHR colorSpace;
+ public:
+ vk::Format format;
+ vk::ColorSpaceKHR colorSpace;
};
static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceFormatKHR>::value, "struct wrapper is not a standard layout!" );
- struct SurfaceFormat2KHR
+ namespace layout
{
+ struct SurfaceFormat2KHR
+ {
+ protected:
+ SurfaceFormat2KHR()
+ {}
+
+ SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFormat2KHR*>(this) = rhs;
+ }
+
+ SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFormat2KHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceFormat2KHR;
+ void* pNext = nullptr;
+ vk::SurfaceFormatKHR surfaceFormat;
+ };
+ static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceFormat2KHR : public layout::SurfaceFormat2KHR
+ {
+ SurfaceFormat2KHR()
+ : layout::SurfaceFormat2KHR()
+ {}
+
+ SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs )
+ : layout::SurfaceFormat2KHR( rhs )
+ {}
+
+ SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs )
+ {
+ layout::SurfaceFormat2KHR::operator=(rhs);
+ return *this;
+ }
+
operator VkSurfaceFormat2KHR const&() const
{
return *reinterpret_cast<const VkSurfaceFormat2KHR*>( this );
@@ -47788,29 +62997,54 @@
}
private:
- StructureType sType = StructureType::eSurfaceFormat2KHR;
-
- public:
- void* pNext = nullptr;
- SurfaceFormatKHR surfaceFormat;
+ using layout::SurfaceFormat2KHR::sType;
};
static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceFormat2KHR>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct SurfaceFullScreenExclusiveInfoEXT
+
+ namespace layout
{
- SurfaceFullScreenExclusiveInfoEXT( FullScreenExclusiveEXT fullScreenExclusive_ = FullScreenExclusiveEXT::eDefault )
- : fullScreenExclusive( fullScreenExclusive_ )
+ struct SurfaceFullScreenExclusiveInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault )
+ : fullScreenExclusive( fullScreenExclusive_ )
+ {}
+
+ SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
+ }
+
+ SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
+ void* pNext = nullptr;
+ vk::FullScreenExclusiveEXT fullScreenExclusive;
+ };
+ static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceFullScreenExclusiveInfoEXT : public layout::SurfaceFullScreenExclusiveInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault )
+ : layout::SurfaceFullScreenExclusiveInfoEXT( fullScreenExclusive_ )
{}
SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) );
- }
+ : layout::SurfaceFullScreenExclusiveInfoEXT( rhs )
+ {}
SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveInfoEXT ) );
+ layout::SurfaceFullScreenExclusiveInfoEXT::operator=(rhs);
return *this;
}
@@ -47820,7 +63054,7 @@
return *this;
}
- SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ )
+ SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( vk::FullScreenExclusiveEXT fullScreenExclusive_ )
{
fullScreenExclusive = fullScreenExclusive_;
return *this;
@@ -47849,30 +63083,55 @@
}
private:
- StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT;
-
- public:
- void* pNext = nullptr;
- FullScreenExclusiveEXT fullScreenExclusive;
+ using layout::SurfaceFullScreenExclusiveInfoEXT::sType;
};
static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveInfoEXT>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct SurfaceFullScreenExclusiveWin32InfoEXT
+
+ namespace layout
{
- SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 )
- : hmonitor( hmonitor_ )
+ struct SurfaceFullScreenExclusiveWin32InfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 )
+ : hmonitor( hmonitor_ )
+ {}
+
+ SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
+ }
+
+ SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
+ const void* pNext = nullptr;
+ HMONITOR hmonitor;
+ };
+ static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceFullScreenExclusiveWin32InfoEXT : public layout::SurfaceFullScreenExclusiveWin32InfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 )
+ : layout::SurfaceFullScreenExclusiveWin32InfoEXT( hmonitor_ )
{}
SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) );
- }
+ : layout::SurfaceFullScreenExclusiveWin32InfoEXT( rhs )
+ {}
SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) );
+ layout::SurfaceFullScreenExclusiveWin32InfoEXT::operator=(rhs);
return *this;
}
@@ -47911,29 +63170,53 @@
}
private:
- StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT;
-
- public:
- const void* pNext = nullptr;
- HMONITOR hmonitor;
+ using layout::SurfaceFullScreenExclusiveWin32InfoEXT::sType;
};
static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveWin32InfoEXT>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct SurfaceProtectedCapabilitiesKHR
+ namespace layout
{
- SurfaceProtectedCapabilitiesKHR( Bool32 supportsProtected_ = 0 )
- : supportsProtected( supportsProtected_ )
+ struct SurfaceProtectedCapabilitiesKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 )
+ : supportsProtected( supportsProtected_ )
+ {}
+
+ SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
+ }
+
+ SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs )
+ {
+ *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR;
+ const void* pNext = nullptr;
+ vk::Bool32 supportsProtected;
+ };
+ static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SurfaceProtectedCapabilitiesKHR : public layout::SurfaceProtectedCapabilitiesKHR
+ {
+ VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 )
+ : layout::SurfaceProtectedCapabilitiesKHR( supportsProtected_ )
{}
SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) );
- }
+ : layout::SurfaceProtectedCapabilitiesKHR( rhs )
+ {}
SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SurfaceProtectedCapabilitiesKHR ) );
+ layout::SurfaceProtectedCapabilitiesKHR::operator=(rhs);
return *this;
}
@@ -47943,7 +63226,7 @@
return *this;
}
- SurfaceProtectedCapabilitiesKHR & setSupportsProtected( Bool32 supportsProtected_ )
+ SurfaceProtectedCapabilitiesKHR & setSupportsProtected( vk::Bool32 supportsProtected_ )
{
supportsProtected = supportsProtected_;
return *this;
@@ -47972,28 +63255,52 @@
}
private:
- StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR;
-
- public:
- const void* pNext = nullptr;
- Bool32 supportsProtected;
+ using layout::SurfaceProtectedCapabilitiesKHR::sType;
};
static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SurfaceProtectedCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
- struct SwapchainCounterCreateInfoEXT
+ namespace layout
{
- SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
- : surfaceCounters( surfaceCounters_ )
+ struct SwapchainCounterCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() )
+ : surfaceCounters( surfaceCounters_ )
+ {}
+
+ SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
+ }
+
+ SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::SurfaceCounterFlagsEXT surfaceCounters;
+ };
+ static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SwapchainCounterCreateInfoEXT : public layout::SwapchainCounterCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() )
+ : layout::SwapchainCounterCreateInfoEXT( surfaceCounters_ )
{}
SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
- }
+ : layout::SwapchainCounterCreateInfoEXT( rhs )
+ {}
SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
+ layout::SwapchainCounterCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -48003,7 +63310,7 @@
return *this;
}
- SwapchainCounterCreateInfoEXT & setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
+ SwapchainCounterCreateInfoEXT & setSurfaceCounters( vk::SurfaceCounterFlagsEXT surfaceCounters_ )
{
surfaceCounters = surfaceCounters_;
return *this;
@@ -48032,58 +63339,112 @@
}
private:
- StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- SurfaceCounterFlagsEXT surfaceCounters;
+ using layout::SwapchainCounterCreateInfoEXT::sType;
};
static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SwapchainCounterCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct SwapchainCreateInfoKHR
+ namespace layout
{
- 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() )
- : flags( flags_ )
- , surface( surface_ )
- , minImageCount( minImageCount_ )
- , imageFormat( imageFormat_ )
- , imageColorSpace( imageColorSpace_ )
- , imageExtent( imageExtent_ )
- , imageArrayLayers( imageArrayLayers_ )
- , imageUsage( imageUsage_ )
- , imageSharingMode( imageSharingMode_ )
- , queueFamilyIndexCount( queueFamilyIndexCount_ )
- , pQueueFamilyIndices( pQueueFamilyIndices_ )
- , preTransform( preTransform_ )
- , compositeAlpha( compositeAlpha_ )
- , presentMode( presentMode_ )
- , clipped( clipped_ )
- , oldSwapchain( oldSwapchain_ )
+ struct SwapchainCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(),
+ vk::SurfaceKHR surface_ = vk::SurfaceKHR(),
+ uint32_t minImageCount_ = 0,
+ vk::Format imageFormat_ = vk::Format::eUndefined,
+ vk::ColorSpaceKHR imageColorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear,
+ vk::Extent2D imageExtent_ = vk::Extent2D(),
+ uint32_t imageArrayLayers_ = 0,
+ vk::ImageUsageFlags imageUsage_ = vk::ImageUsageFlags(),
+ vk::SharingMode imageSharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr,
+ vk::SurfaceTransformFlagBitsKHR preTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+ vk::CompositeAlphaFlagBitsKHR compositeAlpha_ = vk::CompositeAlphaFlagBitsKHR::eOpaque,
+ vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate,
+ vk::Bool32 clipped_ = 0,
+ vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() )
+ : flags( flags_ )
+ , surface( surface_ )
+ , minImageCount( minImageCount_ )
+ , imageFormat( imageFormat_ )
+ , imageColorSpace( imageColorSpace_ )
+ , imageExtent( imageExtent_ )
+ , imageArrayLayers( imageArrayLayers_ )
+ , imageUsage( imageUsage_ )
+ , imageSharingMode( imageSharingMode_ )
+ , queueFamilyIndexCount( queueFamilyIndexCount_ )
+ , pQueueFamilyIndices( pQueueFamilyIndices_ )
+ , preTransform( preTransform_ )
+ , compositeAlpha( compositeAlpha_ )
+ , presentMode( presentMode_ )
+ , clipped( clipped_ )
+ , oldSwapchain( oldSwapchain_ )
+ {}
+
+ SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this) = rhs;
+ }
+
+ SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSwapchainCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::SwapchainCreateFlagsKHR flags;
+ vk::SurfaceKHR surface;
+ uint32_t minImageCount;
+ vk::Format imageFormat;
+ vk::ColorSpaceKHR imageColorSpace;
+ vk::Extent2D imageExtent;
+ uint32_t imageArrayLayers;
+ vk::ImageUsageFlags imageUsage;
+ vk::SharingMode imageSharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ vk::SurfaceTransformFlagBitsKHR preTransform;
+ vk::CompositeAlphaFlagBitsKHR compositeAlpha;
+ vk::PresentModeKHR presentMode;
+ vk::Bool32 clipped;
+ vk::SwapchainKHR oldSwapchain;
+ };
+ static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SwapchainCreateInfoKHR : public layout::SwapchainCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(),
+ vk::SurfaceKHR surface_ = vk::SurfaceKHR(),
+ uint32_t minImageCount_ = 0,
+ vk::Format imageFormat_ = vk::Format::eUndefined,
+ vk::ColorSpaceKHR imageColorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear,
+ vk::Extent2D imageExtent_ = vk::Extent2D(),
+ uint32_t imageArrayLayers_ = 0,
+ vk::ImageUsageFlags imageUsage_ = vk::ImageUsageFlags(),
+ vk::SharingMode imageSharingMode_ = vk::SharingMode::eExclusive,
+ uint32_t queueFamilyIndexCount_ = 0,
+ const uint32_t* pQueueFamilyIndices_ = nullptr,
+ vk::SurfaceTransformFlagBitsKHR preTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity,
+ vk::CompositeAlphaFlagBitsKHR compositeAlpha_ = vk::CompositeAlphaFlagBitsKHR::eOpaque,
+ vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate,
+ vk::Bool32 clipped_ = 0,
+ vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() )
+ : layout::SwapchainCreateInfoKHR( flags_, surface_, minImageCount_, imageFormat_, imageColorSpace_, imageExtent_, imageArrayLayers_, imageUsage_, imageSharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, preTransform_, compositeAlpha_, presentMode_, clipped_, oldSwapchain_ )
{}
SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
- }
+ : layout::SwapchainCreateInfoKHR( rhs )
+ {}
SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
+ layout::SwapchainCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -48093,13 +63454,13 @@
return *this;
}
- SwapchainCreateInfoKHR & setFlags( SwapchainCreateFlagsKHR flags_ )
+ SwapchainCreateInfoKHR & setFlags( vk::SwapchainCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
}
- SwapchainCreateInfoKHR & setSurface( SurfaceKHR surface_ )
+ SwapchainCreateInfoKHR & setSurface( vk::SurfaceKHR surface_ )
{
surface = surface_;
return *this;
@@ -48111,19 +63472,19 @@
return *this;
}
- SwapchainCreateInfoKHR & setImageFormat( Format imageFormat_ )
+ SwapchainCreateInfoKHR & setImageFormat( vk::Format imageFormat_ )
{
imageFormat = imageFormat_;
return *this;
}
- SwapchainCreateInfoKHR & setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
+ SwapchainCreateInfoKHR & setImageColorSpace( vk::ColorSpaceKHR imageColorSpace_ )
{
imageColorSpace = imageColorSpace_;
return *this;
}
- SwapchainCreateInfoKHR & setImageExtent( Extent2D imageExtent_ )
+ SwapchainCreateInfoKHR & setImageExtent( vk::Extent2D imageExtent_ )
{
imageExtent = imageExtent_;
return *this;
@@ -48135,13 +63496,13 @@
return *this;
}
- SwapchainCreateInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ )
+ SwapchainCreateInfoKHR & setImageUsage( vk::ImageUsageFlags imageUsage_ )
{
imageUsage = imageUsage_;
return *this;
}
- SwapchainCreateInfoKHR & setImageSharingMode( SharingMode imageSharingMode_ )
+ SwapchainCreateInfoKHR & setImageSharingMode( vk::SharingMode imageSharingMode_ )
{
imageSharingMode = imageSharingMode_;
return *this;
@@ -48159,31 +63520,31 @@
return *this;
}
- SwapchainCreateInfoKHR & setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
+ SwapchainCreateInfoKHR & setPreTransform( vk::SurfaceTransformFlagBitsKHR preTransform_ )
{
preTransform = preTransform_;
return *this;
}
- SwapchainCreateInfoKHR & setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
+ SwapchainCreateInfoKHR & setCompositeAlpha( vk::CompositeAlphaFlagBitsKHR compositeAlpha_ )
{
compositeAlpha = compositeAlpha_;
return *this;
}
- SwapchainCreateInfoKHR & setPresentMode( PresentModeKHR presentMode_ )
+ SwapchainCreateInfoKHR & setPresentMode( vk::PresentModeKHR presentMode_ )
{
presentMode = presentMode_;
return *this;
}
- SwapchainCreateInfoKHR & setClipped( Bool32 clipped_ )
+ SwapchainCreateInfoKHR & setClipped( vk::Bool32 clipped_ )
{
clipped = clipped_;
return *this;
}
- SwapchainCreateInfoKHR & setOldSwapchain( SwapchainKHR oldSwapchain_ )
+ SwapchainCreateInfoKHR & setOldSwapchain( vk::SwapchainKHR oldSwapchain_ )
{
oldSwapchain = oldSwapchain_;
return *this;
@@ -48227,43 +63588,52 @@
}
private:
- StructureType sType = StructureType::eSwapchainCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- SwapchainCreateFlagsKHR flags;
- SurfaceKHR surface;
- uint32_t minImageCount;
- Format imageFormat;
- ColorSpaceKHR imageColorSpace;
- Extent2D imageExtent;
- uint32_t imageArrayLayers;
- ImageUsageFlags imageUsage;
- SharingMode imageSharingMode;
- uint32_t queueFamilyIndexCount;
- const uint32_t* pQueueFamilyIndices;
- SurfaceTransformFlagBitsKHR preTransform;
- CompositeAlphaFlagBitsKHR compositeAlpha;
- PresentModeKHR presentMode;
- Bool32 clipped;
- SwapchainKHR oldSwapchain;
+ using layout::SwapchainCreateInfoKHR::sType;
};
static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
- struct SwapchainDisplayNativeHdrCreateInfoAMD
+ namespace layout
{
- SwapchainDisplayNativeHdrCreateInfoAMD( Bool32 localDimmingEnable_ = 0 )
- : localDimmingEnable( localDimmingEnable_ )
+ struct SwapchainDisplayNativeHdrCreateInfoAMD
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 )
+ : localDimmingEnable( localDimmingEnable_ )
+ {}
+
+ SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
+ }
+
+ SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
+ {
+ *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
+ const void* pNext = nullptr;
+ vk::Bool32 localDimmingEnable;
+ };
+ static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct SwapchainDisplayNativeHdrCreateInfoAMD : public layout::SwapchainDisplayNativeHdrCreateInfoAMD
+ {
+ VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 )
+ : layout::SwapchainDisplayNativeHdrCreateInfoAMD( localDimmingEnable_ )
{}
SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
- {
- memcpy( this, &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) );
- }
+ : layout::SwapchainDisplayNativeHdrCreateInfoAMD( rhs )
+ {}
SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs )
{
- memcpy( this, &rhs, sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) );
+ layout::SwapchainDisplayNativeHdrCreateInfoAMD::operator=(rhs);
return *this;
}
@@ -48273,7 +63643,7 @@
return *this;
}
- SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( Bool32 localDimmingEnable_ )
+ SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( vk::Bool32 localDimmingEnable_ )
{
localDimmingEnable = localDimmingEnable_;
return *this;
@@ -48302,16 +63672,54 @@
}
private:
- StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD;
-
- public:
- const void* pNext = nullptr;
- Bool32 localDimmingEnable;
+ using layout::SwapchainDisplayNativeHdrCreateInfoAMD::sType;
};
static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<SwapchainDisplayNativeHdrCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
- struct TextureLODGatherFormatPropertiesAMD
+ namespace layout
{
+ struct TextureLODGatherFormatPropertiesAMD
+ {
+ protected:
+ TextureLODGatherFormatPropertiesAMD()
+ {}
+
+ TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs )
+ {
+ *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this) = rhs;
+ }
+
+ TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs )
+ {
+ *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
+ void* pNext = nullptr;
+ vk::Bool32 supportsTextureGatherLODBiasAMD;
+ };
+ static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "layout struct and wrapper have different size!" );
+ }
+
+ struct TextureLODGatherFormatPropertiesAMD : public layout::TextureLODGatherFormatPropertiesAMD
+ {
+ TextureLODGatherFormatPropertiesAMD()
+ : layout::TextureLODGatherFormatPropertiesAMD()
+ {}
+
+ TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs )
+ : layout::TextureLODGatherFormatPropertiesAMD( rhs )
+ {}
+
+ TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs )
+ {
+ layout::TextureLODGatherFormatPropertiesAMD::operator=(rhs);
+ return *this;
+ }
+
operator VkTextureLODGatherFormatPropertiesAMD const&() const
{
return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>( this );
@@ -48335,32 +63743,177 @@
}
private:
- StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
-
- public:
- void* pNext = nullptr;
- Bool32 supportsTextureGatherLODBiasAMD;
+ using layout::TextureLODGatherFormatPropertiesAMD::sType;
};
static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<TextureLODGatherFormatPropertiesAMD>::value, "struct wrapper is not a standard layout!" );
- struct ValidationCacheCreateInfoEXT
+ namespace layout
{
- ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(),
- size_t initialDataSize_ = 0,
- const void* pInitialData_ = nullptr )
- : flags( flags_ )
- , initialDataSize( initialDataSize_ )
- , pInitialData( pInitialData_ )
+ struct TimelineSemaphoreSubmitInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0,
+ const uint64_t* pWaitSemaphoreValues_ = nullptr,
+ uint32_t signalSemaphoreValueCount_ = 0,
+ const uint64_t* pSignalSemaphoreValues_ = nullptr )
+ : waitSemaphoreValueCount( waitSemaphoreValueCount_ )
+ , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
+ , signalSemaphoreValueCount( signalSemaphoreValueCount_ )
+ , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
+ {}
+
+ TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkTimelineSemaphoreSubmitInfoKHR*>(this) = rhs;
+ }
+
+ TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkTimelineSemaphoreSubmitInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t waitSemaphoreValueCount;
+ const uint64_t* pWaitSemaphoreValues;
+ uint32_t signalSemaphoreValueCount;
+ const uint64_t* pSignalSemaphoreValues;
+ };
+ static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct TimelineSemaphoreSubmitInfoKHR : public layout::TimelineSemaphoreSubmitInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0,
+ const uint64_t* pWaitSemaphoreValues_ = nullptr,
+ uint32_t signalSemaphoreValueCount_ = 0,
+ const uint64_t* pSignalSemaphoreValues_ = nullptr )
+ : layout::TimelineSemaphoreSubmitInfoKHR( waitSemaphoreValueCount_, pWaitSemaphoreValues_, signalSemaphoreValueCount_, pSignalSemaphoreValues_ )
+ {}
+
+ TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs )
+ : layout::TimelineSemaphoreSubmitInfoKHR( rhs )
+ {}
+
+ TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs )
+ {
+ layout::TimelineSemaphoreSubmitInfoKHR::operator=(rhs);
+ return *this;
+ }
+
+ TimelineSemaphoreSubmitInfoKHR & setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ TimelineSemaphoreSubmitInfoKHR & setWaitSemaphoreValueCount( uint32_t waitSemaphoreValueCount_ )
+ {
+ waitSemaphoreValueCount = waitSemaphoreValueCount_;
+ return *this;
+ }
+
+ TimelineSemaphoreSubmitInfoKHR & setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ )
+ {
+ pWaitSemaphoreValues = pWaitSemaphoreValues_;
+ return *this;
+ }
+
+ TimelineSemaphoreSubmitInfoKHR & setSignalSemaphoreValueCount( uint32_t signalSemaphoreValueCount_ )
+ {
+ signalSemaphoreValueCount = signalSemaphoreValueCount_;
+ return *this;
+ }
+
+ TimelineSemaphoreSubmitInfoKHR & setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ )
+ {
+ pSignalSemaphoreValues = pSignalSemaphoreValues_;
+ return *this;
+ }
+
+ operator VkTimelineSemaphoreSubmitInfoKHR const&() const
+ {
+ return *reinterpret_cast<const VkTimelineSemaphoreSubmitInfoKHR*>( this );
+ }
+
+ operator VkTimelineSemaphoreSubmitInfoKHR &()
+ {
+ return *reinterpret_cast<VkTimelineSemaphoreSubmitInfoKHR*>( this );
+ }
+
+ bool operator==( TimelineSemaphoreSubmitInfoKHR const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount )
+ && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues )
+ && ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount )
+ && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+ }
+
+ bool operator!=( TimelineSemaphoreSubmitInfoKHR const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ using layout::TimelineSemaphoreSubmitInfoKHR::sType;
+ };
+ static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<TimelineSemaphoreSubmitInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ namespace layout
+ {
+ struct ValidationCacheCreateInfoEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(),
+ size_t initialDataSize_ = 0,
+ const void* pInitialData_ = nullptr )
+ : flags( flags_ )
+ , initialDataSize( initialDataSize_ )
+ , pInitialData( pInitialData_ )
+ {}
+
+ ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this) = rhs;
+ }
+
+ ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
+ {
+ *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
+ const void* pNext = nullptr;
+ vk::ValidationCacheCreateFlagsEXT flags;
+ size_t initialDataSize;
+ const void* pInitialData;
+ };
+ static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ValidationCacheCreateInfoEXT : public layout::ValidationCacheCreateInfoEXT
+ {
+ VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(),
+ size_t initialDataSize_ = 0,
+ const void* pInitialData_ = nullptr )
+ : layout::ValidationCacheCreateInfoEXT( flags_, initialDataSize_, pInitialData_ )
{}
ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
- }
+ : layout::ValidationCacheCreateInfoEXT( rhs )
+ {}
ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
+ layout::ValidationCacheCreateInfoEXT::operator=(rhs);
return *this;
}
@@ -48370,7 +63923,7 @@
return *this;
}
- ValidationCacheCreateInfoEXT & setFlags( ValidationCacheCreateFlagsEXT flags_ )
+ ValidationCacheCreateInfoEXT & setFlags( vk::ValidationCacheCreateFlagsEXT flags_ )
{
flags = flags_;
return *this;
@@ -48413,36 +63966,64 @@
}
private:
- StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
-
- public:
- const void* pNext = nullptr;
- ValidationCacheCreateFlagsEXT flags;
- size_t initialDataSize;
- const void* pInitialData;
+ using layout::ValidationCacheCreateInfoEXT::sType;
};
static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- struct ValidationFeaturesEXT
+ namespace layout
{
- ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
- const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
- uint32_t disabledValidationFeatureCount_ = 0,
- const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
- : enabledValidationFeatureCount( enabledValidationFeatureCount_ )
- , pEnabledValidationFeatures( pEnabledValidationFeatures_ )
- , disabledValidationFeatureCount( disabledValidationFeatureCount_ )
- , pDisabledValidationFeatures( pDisabledValidationFeatures_ )
+ struct ValidationFeaturesEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
+ const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
+ uint32_t disabledValidationFeatureCount_ = 0,
+ const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
+ : enabledValidationFeatureCount( enabledValidationFeatureCount_ )
+ , pEnabledValidationFeatures( pEnabledValidationFeatures_ )
+ , disabledValidationFeatureCount( disabledValidationFeatureCount_ )
+ , pDisabledValidationFeatures( pDisabledValidationFeatures_ )
+ {}
+
+ ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkValidationFeaturesEXT*>(this) = rhs;
+ }
+
+ ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs )
+ {
+ *reinterpret_cast<VkValidationFeaturesEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eValidationFeaturesEXT;
+ const void* pNext = nullptr;
+ uint32_t enabledValidationFeatureCount;
+ const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures;
+ uint32_t disabledValidationFeatureCount;
+ const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures;
+ };
+ static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ValidationFeaturesEXT : public layout::ValidationFeaturesEXT
+ {
+ VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0,
+ const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr,
+ uint32_t disabledValidationFeatureCount_ = 0,
+ const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr )
+ : layout::ValidationFeaturesEXT( enabledValidationFeatureCount_, pEnabledValidationFeatures_, disabledValidationFeatureCount_, pDisabledValidationFeatures_ )
{}
ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ValidationFeaturesEXT ) );
- }
+ : layout::ValidationFeaturesEXT( rhs )
+ {}
ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ValidationFeaturesEXT ) );
+ layout::ValidationFeaturesEXT::operator=(rhs);
return *this;
}
@@ -48458,7 +64039,7 @@
return *this;
}
- ValidationFeaturesEXT & setPEnabledValidationFeatures( const ValidationFeatureEnableEXT* pEnabledValidationFeatures_ )
+ ValidationFeaturesEXT & setPEnabledValidationFeatures( const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ )
{
pEnabledValidationFeatures = pEnabledValidationFeatures_;
return *this;
@@ -48470,7 +64051,7 @@
return *this;
}
- ValidationFeaturesEXT & setPDisabledValidationFeatures( const ValidationFeatureDisableEXT* pDisabledValidationFeatures_ )
+ ValidationFeaturesEXT & setPDisabledValidationFeatures( const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ )
{
pDisabledValidationFeatures = pDisabledValidationFeatures_;
return *this;
@@ -48502,33 +64083,56 @@
}
private:
- StructureType sType = StructureType::eValidationFeaturesEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t enabledValidationFeatureCount;
- const ValidationFeatureEnableEXT* pEnabledValidationFeatures;
- uint32_t disabledValidationFeatureCount;
- const ValidationFeatureDisableEXT* pDisabledValidationFeatures;
+ using layout::ValidationFeaturesEXT::sType;
};
static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ValidationFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- struct ValidationFlagsEXT
+ namespace layout
{
- ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
- const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
- : disabledValidationCheckCount( disabledValidationCheckCount_ )
- , pDisabledValidationChecks( pDisabledValidationChecks_ )
+ struct ValidationFlagsEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
+ const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+ : disabledValidationCheckCount( disabledValidationCheckCount_ )
+ , pDisabledValidationChecks( pDisabledValidationChecks_ )
+ {}
+
+ ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
+ {
+ *reinterpret_cast<VkValidationFlagsEXT*>(this) = rhs;
+ }
+
+ ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
+ {
+ *reinterpret_cast<VkValidationFlagsEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eValidationFlagsEXT;
+ const void* pNext = nullptr;
+ uint32_t disabledValidationCheckCount;
+ const vk::ValidationCheckEXT* pDisabledValidationChecks;
+ };
+ static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ValidationFlagsEXT : public layout::ValidationFlagsEXT
+ {
+ VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
+ const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
+ : layout::ValidationFlagsEXT( disabledValidationCheckCount_, pDisabledValidationChecks_ )
{}
ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
- }
+ : layout::ValidationFlagsEXT( rhs )
+ {}
ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
+ layout::ValidationFlagsEXT::operator=(rhs);
return *this;
}
@@ -48544,7 +64148,7 @@
return *this;
}
- ValidationFlagsEXT & setPDisabledValidationChecks( const ValidationCheckEXT* pDisabledValidationChecks_ )
+ ValidationFlagsEXT & setPDisabledValidationChecks( const vk::ValidationCheckEXT* pDisabledValidationChecks_ )
{
pDisabledValidationChecks = pDisabledValidationChecks_;
return *this;
@@ -48574,32 +64178,58 @@
}
private:
- StructureType sType = StructureType::eValidationFlagsEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t disabledValidationCheckCount;
- const ValidationCheckEXT* pDisabledValidationChecks;
+ using layout::ValidationFlagsEXT::sType;
};
static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ValidationFlagsEXT>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_VI_NN
- struct ViSurfaceCreateInfoNN
+
+ namespace layout
{
- ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(),
- void* window_ = nullptr )
- : flags( flags_ )
- , window( window_ )
+ struct ViSurfaceCreateInfoNN
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(),
+ void* window_ = nullptr )
+ : flags( flags_ )
+ , window( window_ )
+ {}
+
+ ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
+ {
+ *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this) = rhs;
+ }
+
+ ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
+ {
+ *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN;
+ const void* pNext = nullptr;
+ vk::ViSurfaceCreateFlagsNN flags;
+ void* window;
+ };
+ static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "layout struct and wrapper have different size!" );
+ }
+
+ struct ViSurfaceCreateInfoNN : public layout::ViSurfaceCreateInfoNN
+ {
+ VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(),
+ void* window_ = nullptr )
+ : layout::ViSurfaceCreateInfoNN( flags_, window_ )
{}
ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
- {
- memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
- }
+ : layout::ViSurfaceCreateInfoNN( rhs )
+ {}
ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
{
- memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
+ layout::ViSurfaceCreateInfoNN::operator=(rhs);
return *this;
}
@@ -48609,7 +64239,7 @@
return *this;
}
- ViSurfaceCreateInfoNN & setFlags( ViSurfaceCreateFlagsNN flags_ )
+ ViSurfaceCreateInfoNN & setFlags( vk::ViSurfaceCreateFlagsNN flags_ )
{
flags = flags_;
return *this;
@@ -48645,35 +64275,63 @@
}
private:
- StructureType sType = StructureType::eViSurfaceCreateInfoNN;
-
- public:
- const void* pNext = nullptr;
- ViSurfaceCreateFlagsNN flags;
- void* window;
+ using layout::ViSurfaceCreateInfoNN::sType;
};
static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<ViSurfaceCreateInfoNN>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_VI_NN*/
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
- struct WaylandSurfaceCreateInfoKHR
+
+ namespace layout
{
- WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(),
- struct wl_display* display_ = nullptr,
- struct wl_surface* surface_ = nullptr )
- : flags( flags_ )
- , display( display_ )
- , surface( surface_ )
+ struct WaylandSurfaceCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(),
+ struct wl_display* display_ = nullptr,
+ struct wl_surface* surface_ = nullptr )
+ : flags( flags_ )
+ , display( display_ )
+ , surface( surface_ )
+ {}
+
+ WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
+ }
+
+ WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::WaylandSurfaceCreateFlagsKHR flags;
+ struct wl_display* display;
+ struct wl_surface* surface;
+ };
+ static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct WaylandSurfaceCreateInfoKHR : public layout::WaylandSurfaceCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(),
+ struct wl_display* display_ = nullptr,
+ struct wl_surface* surface_ = nullptr )
+ : layout::WaylandSurfaceCreateInfoKHR( flags_, display_, surface_ )
{}
WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
- }
+ : layout::WaylandSurfaceCreateInfoKHR( rhs )
+ {}
WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
+ layout::WaylandSurfaceCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -48683,7 +64341,7 @@
return *this;
}
- WaylandSurfaceCreateInfoKHR & setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
+ WaylandSurfaceCreateInfoKHR & setFlags( vk::WaylandSurfaceCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
@@ -48726,44 +64384,79 @@
}
private:
- StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- WaylandSurfaceCreateFlagsKHR flags;
- struct wl_display* display;
- struct wl_surface* surface;
+ using layout::WaylandSurfaceCreateInfoKHR::sType;
};
static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<WaylandSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct Win32KeyedMutexAcquireReleaseInfoKHR
+
+ namespace layout
{
- Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
- const DeviceMemory* pAcquireSyncs_ = nullptr,
- const uint64_t* pAcquireKeys_ = nullptr,
- const uint32_t* pAcquireTimeouts_ = nullptr,
- uint32_t releaseCount_ = 0,
- const DeviceMemory* pReleaseSyncs_ = nullptr,
- const uint64_t* pReleaseKeys_ = nullptr )
- : acquireCount( acquireCount_ )
- , pAcquireSyncs( pAcquireSyncs_ )
- , pAcquireKeys( pAcquireKeys_ )
- , pAcquireTimeouts( pAcquireTimeouts_ )
- , releaseCount( releaseCount_ )
- , pReleaseSyncs( pReleaseSyncs_ )
- , pReleaseKeys( pReleaseKeys_ )
+ struct Win32KeyedMutexAcquireReleaseInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
+ const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
+ const uint64_t* pAcquireKeys_ = nullptr,
+ const uint32_t* pAcquireTimeouts_ = nullptr,
+ uint32_t releaseCount_ = 0,
+ const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
+ const uint64_t* pReleaseKeys_ = nullptr )
+ : acquireCount( acquireCount_ )
+ , pAcquireSyncs( pAcquireSyncs_ )
+ , pAcquireKeys( pAcquireKeys_ )
+ , pAcquireTimeouts( pAcquireTimeouts_ )
+ , releaseCount( releaseCount_ )
+ , pReleaseSyncs( pReleaseSyncs_ )
+ , pReleaseKeys( pReleaseKeys_ )
+ {}
+
+ Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
+ }
+
+ Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
+ const void* pNext = nullptr;
+ uint32_t acquireCount;
+ const vk::DeviceMemory* pAcquireSyncs;
+ const uint64_t* pAcquireKeys;
+ const uint32_t* pAcquireTimeouts;
+ uint32_t releaseCount;
+ const vk::DeviceMemory* pReleaseSyncs;
+ const uint64_t* pReleaseKeys;
+ };
+ static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct Win32KeyedMutexAcquireReleaseInfoKHR : public layout::Win32KeyedMutexAcquireReleaseInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
+ const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
+ const uint64_t* pAcquireKeys_ = nullptr,
+ const uint32_t* pAcquireTimeouts_ = nullptr,
+ uint32_t releaseCount_ = 0,
+ const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
+ const uint64_t* pReleaseKeys_ = nullptr )
+ : layout::Win32KeyedMutexAcquireReleaseInfoKHR( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeouts_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ )
{}
Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
- }
+ : layout::Win32KeyedMutexAcquireReleaseInfoKHR( rhs )
+ {}
Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
+ layout::Win32KeyedMutexAcquireReleaseInfoKHR::operator=(rhs);
return *this;
}
@@ -48779,7 +64472,7 @@
return *this;
}
- Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+ Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const vk::DeviceMemory* pAcquireSyncs_ )
{
pAcquireSyncs = pAcquireSyncs_;
return *this;
@@ -48803,7 +64496,7 @@
return *this;
}
- Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+ Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const vk::DeviceMemory* pReleaseSyncs_ )
{
pReleaseSyncs = pReleaseSyncs_;
return *this;
@@ -48844,48 +64537,79 @@
}
private:
- StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
-
- public:
- const void* pNext = nullptr;
- uint32_t acquireCount;
- const DeviceMemory* pAcquireSyncs;
- const uint64_t* pAcquireKeys;
- const uint32_t* pAcquireTimeouts;
- uint32_t releaseCount;
- const DeviceMemory* pReleaseSyncs;
- const uint64_t* pReleaseKeys;
+ using layout::Win32KeyedMutexAcquireReleaseInfoKHR::sType;
};
static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct Win32KeyedMutexAcquireReleaseInfoNV
+
+ namespace layout
{
- 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 )
- : acquireCount( acquireCount_ )
- , pAcquireSyncs( pAcquireSyncs_ )
- , pAcquireKeys( pAcquireKeys_ )
- , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
- , releaseCount( releaseCount_ )
- , pReleaseSyncs( pReleaseSyncs_ )
- , pReleaseKeys( pReleaseKeys_ )
+ struct Win32KeyedMutexAcquireReleaseInfoNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0,
+ const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
+ const uint64_t* pAcquireKeys_ = nullptr,
+ const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr,
+ uint32_t releaseCount_ = 0,
+ const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
+ const uint64_t* pReleaseKeys_ = nullptr )
+ : acquireCount( acquireCount_ )
+ , pAcquireSyncs( pAcquireSyncs_ )
+ , pAcquireKeys( pAcquireKeys_ )
+ , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
+ , releaseCount( releaseCount_ )
+ , pReleaseSyncs( pReleaseSyncs_ )
+ , pReleaseKeys( pReleaseKeys_ )
+ {}
+
+ Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
+ }
+
+ Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
+ {
+ *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
+ const void* pNext = nullptr;
+ uint32_t acquireCount;
+ const vk::DeviceMemory* pAcquireSyncs;
+ const uint64_t* pAcquireKeys;
+ const uint32_t* pAcquireTimeoutMilliseconds;
+ uint32_t releaseCount;
+ const vk::DeviceMemory* pReleaseSyncs;
+ const uint64_t* pReleaseKeys;
+ };
+ static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct Win32KeyedMutexAcquireReleaseInfoNV : public layout::Win32KeyedMutexAcquireReleaseInfoNV
+ {
+ VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0,
+ const vk::DeviceMemory* pAcquireSyncs_ = nullptr,
+ const uint64_t* pAcquireKeys_ = nullptr,
+ const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr,
+ uint32_t releaseCount_ = 0,
+ const vk::DeviceMemory* pReleaseSyncs_ = nullptr,
+ const uint64_t* pReleaseKeys_ = nullptr )
+ : layout::Win32KeyedMutexAcquireReleaseInfoNV( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeoutMilliseconds_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ )
{}
Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
- }
+ : layout::Win32KeyedMutexAcquireReleaseInfoNV( rhs )
+ {}
Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
+ layout::Win32KeyedMutexAcquireReleaseInfoNV::operator=(rhs);
return *this;
}
@@ -48901,7 +64625,7 @@
return *this;
}
- Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
+ Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const vk::DeviceMemory* pAcquireSyncs_ )
{
pAcquireSyncs = pAcquireSyncs_;
return *this;
@@ -48925,7 +64649,7 @@
return *this;
}
- Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
+ Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const vk::DeviceMemory* pReleaseSyncs_ )
{
pReleaseSyncs = pReleaseSyncs_;
return *this;
@@ -48966,40 +64690,63 @@
}
private:
- StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
-
- public:
- const void* pNext = nullptr;
- uint32_t acquireCount;
- const DeviceMemory* pAcquireSyncs;
- const uint64_t* pAcquireKeys;
- const uint32_t* pAcquireTimeoutMilliseconds;
- uint32_t releaseCount;
- const DeviceMemory* pReleaseSyncs;
- const uint64_t* pReleaseKeys;
+ using layout::Win32KeyedMutexAcquireReleaseInfoNV::sType;
};
static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoNV>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
- struct Win32SurfaceCreateInfoKHR
+
+ namespace layout
{
- Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(),
- HINSTANCE hinstance_ = 0,
- HWND hwnd_ = 0 )
- : flags( flags_ )
- , hinstance( hinstance_ )
- , hwnd( hwnd_ )
+ struct Win32SurfaceCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(),
+ HINSTANCE hinstance_ = 0,
+ HWND hwnd_ = 0 )
+ : flags( flags_ )
+ , hinstance( hinstance_ )
+ , hwnd( hwnd_ )
+ {}
+
+ Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
+ }
+
+ Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::Win32SurfaceCreateFlagsKHR flags;
+ HINSTANCE hinstance;
+ HWND hwnd;
+ };
+ static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct Win32SurfaceCreateInfoKHR : public layout::Win32SurfaceCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(),
+ HINSTANCE hinstance_ = 0,
+ HWND hwnd_ = 0 )
+ : layout::Win32SurfaceCreateInfoKHR( flags_, hinstance_, hwnd_ )
{}
Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
- }
+ : layout::Win32SurfaceCreateInfoKHR( rhs )
+ {}
Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
+ layout::Win32SurfaceCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -49009,7 +64756,7 @@
return *this;
}
- Win32SurfaceCreateInfoKHR & setFlags( Win32SurfaceCreateFlagsKHR flags_ )
+ Win32SurfaceCreateInfoKHR & setFlags( vk::Win32SurfaceCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
@@ -49052,45 +64799,81 @@
}
private:
- StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- Win32SurfaceCreateFlagsKHR flags;
- HINSTANCE hinstance;
- HWND hwnd;
+ using layout::Win32SurfaceCreateInfoKHR::sType;
};
static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<Win32SurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- struct WriteDescriptorSet
+ namespace layout
{
- 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 )
- : dstSet( dstSet_ )
- , dstBinding( dstBinding_ )
- , dstArrayElement( dstArrayElement_ )
- , descriptorCount( descriptorCount_ )
- , descriptorType( descriptorType_ )
- , pImageInfo( pImageInfo_ )
- , pBufferInfo( pBufferInfo_ )
- , pTexelBufferView( pTexelBufferView_ )
+ struct WriteDescriptorSet
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
+ uint32_t dstBinding_ = 0,
+ uint32_t dstArrayElement_ = 0,
+ uint32_t descriptorCount_ = 0,
+ vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+ const vk::DescriptorImageInfo* pImageInfo_ = nullptr,
+ const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr,
+ const vk::BufferView* pTexelBufferView_ = nullptr )
+ : dstSet( dstSet_ )
+ , dstBinding( dstBinding_ )
+ , dstArrayElement( dstArrayElement_ )
+ , descriptorCount( descriptorCount_ )
+ , descriptorType( descriptorType_ )
+ , pImageInfo( pImageInfo_ )
+ , pBufferInfo( pBufferInfo_ )
+ , pTexelBufferView( pTexelBufferView_ )
+ {}
+
+ WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
+ {
+ *reinterpret_cast<VkWriteDescriptorSet*>(this) = rhs;
+ }
+
+ WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
+ {
+ *reinterpret_cast<VkWriteDescriptorSet*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWriteDescriptorSet;
+ const void* pNext = nullptr;
+ vk::DescriptorSet dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ vk::DescriptorType descriptorType;
+ const vk::DescriptorImageInfo* pImageInfo;
+ const vk::DescriptorBufferInfo* pBufferInfo;
+ const vk::BufferView* pTexelBufferView;
+ };
+ static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "layout struct and wrapper have different size!" );
+ }
+
+ struct WriteDescriptorSet : public layout::WriteDescriptorSet
+ {
+ VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(),
+ uint32_t dstBinding_ = 0,
+ uint32_t dstArrayElement_ = 0,
+ uint32_t descriptorCount_ = 0,
+ vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler,
+ const vk::DescriptorImageInfo* pImageInfo_ = nullptr,
+ const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr,
+ const vk::BufferView* pTexelBufferView_ = nullptr )
+ : layout::WriteDescriptorSet( dstSet_, dstBinding_, dstArrayElement_, descriptorCount_, descriptorType_, pImageInfo_, pBufferInfo_, pTexelBufferView_ )
{}
WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
- {
- memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
- }
+ : layout::WriteDescriptorSet( rhs )
+ {}
WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
{
- memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
+ layout::WriteDescriptorSet::operator=(rhs);
return *this;
}
@@ -49100,7 +64883,7 @@
return *this;
}
- WriteDescriptorSet & setDstSet( DescriptorSet dstSet_ )
+ WriteDescriptorSet & setDstSet( vk::DescriptorSet dstSet_ )
{
dstSet = dstSet_;
return *this;
@@ -49124,25 +64907,25 @@
return *this;
}
- WriteDescriptorSet & setDescriptorType( DescriptorType descriptorType_ )
+ WriteDescriptorSet & setDescriptorType( vk::DescriptorType descriptorType_ )
{
descriptorType = descriptorType_;
return *this;
}
- WriteDescriptorSet & setPImageInfo( const DescriptorImageInfo* pImageInfo_ )
+ WriteDescriptorSet & setPImageInfo( const vk::DescriptorImageInfo* pImageInfo_ )
{
pImageInfo = pImageInfo_;
return *this;
}
- WriteDescriptorSet & setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ )
+ WriteDescriptorSet & setPBufferInfo( const vk::DescriptorBufferInfo* pBufferInfo_ )
{
pBufferInfo = pBufferInfo_;
return *this;
}
- WriteDescriptorSet & setPTexelBufferView( const BufferView* pTexelBufferView_ )
+ WriteDescriptorSet & setPTexelBufferView( const vk::BufferView* pTexelBufferView_ )
{
pTexelBufferView = pTexelBufferView_;
return *this;
@@ -49178,37 +64961,56 @@
}
private:
- StructureType sType = StructureType::eWriteDescriptorSet;
-
- public:
- const void* pNext = nullptr;
- DescriptorSet dstSet;
- uint32_t dstBinding;
- uint32_t dstArrayElement;
- uint32_t descriptorCount;
- DescriptorType descriptorType;
- const DescriptorImageInfo* pImageInfo;
- const DescriptorBufferInfo* pBufferInfo;
- const BufferView* pTexelBufferView;
+ using layout::WriteDescriptorSet::sType;
};
static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<WriteDescriptorSet>::value, "struct wrapper is not a standard layout!" );
- struct WriteDescriptorSetAccelerationStructureNV
+ namespace layout
{
- WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
- const AccelerationStructureNV* pAccelerationStructures_ = nullptr )
- : accelerationStructureCount( accelerationStructureCount_ )
- , pAccelerationStructures( pAccelerationStructures_ )
+ struct WriteDescriptorSetAccelerationStructureNV
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
+ const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr )
+ : accelerationStructureCount( accelerationStructureCount_ )
+ , pAccelerationStructures( pAccelerationStructures_ )
+ {}
+
+ WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
+ {
+ *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
+ }
+
+ WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
+ {
+ *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
+ const void* pNext = nullptr;
+ uint32_t accelerationStructureCount;
+ const vk::AccelerationStructureNV* pAccelerationStructures;
+ };
+ static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "layout struct and wrapper have different size!" );
+ }
+
+ struct WriteDescriptorSetAccelerationStructureNV : public layout::WriteDescriptorSetAccelerationStructureNV
+ {
+ VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
+ const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr )
+ : layout::WriteDescriptorSetAccelerationStructureNV( accelerationStructureCount_, pAccelerationStructures_ )
{}
WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
- {
- memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
- }
+ : layout::WriteDescriptorSetAccelerationStructureNV( rhs )
+ {}
WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs )
{
- memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
+ layout::WriteDescriptorSetAccelerationStructureNV::operator=(rhs);
return *this;
}
@@ -49224,7 +65026,7 @@
return *this;
}
- WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const AccelerationStructureNV* pAccelerationStructures_ )
+ WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const vk::AccelerationStructureNV* pAccelerationStructures_ )
{
pAccelerationStructures = pAccelerationStructures_;
return *this;
@@ -49254,31 +65056,56 @@
}
private:
- StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV;
-
- public:
- const void* pNext = nullptr;
- uint32_t accelerationStructureCount;
- const AccelerationStructureNV* pAccelerationStructures;
+ using layout::WriteDescriptorSetAccelerationStructureNV::sType;
};
static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<WriteDescriptorSetAccelerationStructureNV>::value, "struct wrapper is not a standard layout!" );
- struct WriteDescriptorSetInlineUniformBlockEXT
+ namespace layout
{
- WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
- const void* pData_ = nullptr )
- : dataSize( dataSize_ )
- , pData( pData_ )
+ struct WriteDescriptorSetInlineUniformBlockEXT
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
+ const void* pData_ = nullptr )
+ : dataSize( dataSize_ )
+ , pData( pData_ )
+ {}
+
+ WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+ {
+ *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
+ }
+
+ WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
+ {
+ *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
+ const void* pNext = nullptr;
+ uint32_t dataSize;
+ const void* pData;
+ };
+ static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "layout struct and wrapper have different size!" );
+ }
+
+ struct WriteDescriptorSetInlineUniformBlockEXT : public layout::WriteDescriptorSetInlineUniformBlockEXT
+ {
+ VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0,
+ const void* pData_ = nullptr )
+ : layout::WriteDescriptorSetInlineUniformBlockEXT( dataSize_, pData_ )
{}
WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
- {
- memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
- }
+ : layout::WriteDescriptorSetInlineUniformBlockEXT( rhs )
+ {}
WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs )
{
- memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
+ layout::WriteDescriptorSetInlineUniformBlockEXT::operator=(rhs);
return *this;
}
@@ -49324,34 +65151,62 @@
}
private:
- StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT;
-
- public:
- const void* pNext = nullptr;
- uint32_t dataSize;
- const void* pData;
+ using layout::WriteDescriptorSetInlineUniformBlockEXT::sType;
};
static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<WriteDescriptorSetInlineUniformBlockEXT>::value, "struct wrapper is not a standard layout!" );
#ifdef VK_USE_PLATFORM_XCB_KHR
- struct XcbSurfaceCreateInfoKHR
+
+ namespace layout
{
- XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(),
- xcb_connection_t* connection_ = nullptr,
- xcb_window_t window_ = 0 )
- : flags( flags_ )
- , connection( connection_ )
- , window( window_ )
+ struct XcbSurfaceCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(),
+ xcb_connection_t* connection_ = nullptr,
+ xcb_window_t window_ = 0 )
+ : flags( flags_ )
+ , connection( connection_ )
+ , window( window_ )
+ {}
+
+ XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
+ }
+
+ XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::XcbSurfaceCreateFlagsKHR flags;
+ xcb_connection_t* connection;
+ xcb_window_t window;
+ };
+ static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct XcbSurfaceCreateInfoKHR : public layout::XcbSurfaceCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(),
+ xcb_connection_t* connection_ = nullptr,
+ xcb_window_t window_ = 0 )
+ : layout::XcbSurfaceCreateInfoKHR( flags_, connection_, window_ )
{}
XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
- }
+ : layout::XcbSurfaceCreateInfoKHR( rhs )
+ {}
XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
+ layout::XcbSurfaceCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -49361,7 +65216,7 @@
return *this;
}
- XcbSurfaceCreateInfoKHR & setFlags( XcbSurfaceCreateFlagsKHR flags_ )
+ XcbSurfaceCreateInfoKHR & setFlags( vk::XcbSurfaceCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
@@ -49404,36 +65259,63 @@
}
private:
- StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- XcbSurfaceCreateFlagsKHR flags;
- xcb_connection_t* connection;
- xcb_window_t window;
+ using layout::XcbSurfaceCreateInfoKHR::sType;
};
static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<XcbSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#ifdef VK_USE_PLATFORM_XLIB_KHR
- struct XlibSurfaceCreateInfoKHR
+
+ namespace layout
{
- XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(),
- Display* dpy_ = nullptr,
- Window window_ = 0 )
- : flags( flags_ )
- , dpy( dpy_ )
- , window( window_ )
+ struct XlibSurfaceCreateInfoKHR
+ {
+ protected:
+ VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(),
+ Display* dpy_ = nullptr,
+ Window window_ = 0 )
+ : flags( flags_ )
+ , dpy( dpy_ )
+ , window( window_ )
+ {}
+
+ XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
+ }
+
+ XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
+ {
+ *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
+ return *this;
+ }
+
+ public:
+ vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
+ const void* pNext = nullptr;
+ vk::XlibSurfaceCreateFlagsKHR flags;
+ Display* dpy;
+ Window window;
+ };
+ static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" );
+ }
+
+ struct XlibSurfaceCreateInfoKHR : public layout::XlibSurfaceCreateInfoKHR
+ {
+ VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(),
+ Display* dpy_ = nullptr,
+ Window window_ = 0 )
+ : layout::XlibSurfaceCreateInfoKHR( flags_, dpy_, window_ )
{}
XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
- {
- memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
- }
+ : layout::XlibSurfaceCreateInfoKHR( rhs )
+ {}
XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
+ layout::XlibSurfaceCreateInfoKHR::operator=(rhs);
return *this;
}
@@ -49443,7 +65325,7 @@
return *this;
}
- XlibSurfaceCreateInfoKHR & setFlags( XlibSurfaceCreateFlagsKHR flags_ )
+ XlibSurfaceCreateInfoKHR & setFlags( vk::XlibSurfaceCreateFlagsKHR flags_ )
{
flags = flags_;
return *this;
@@ -49486,27 +65368,22 @@
}
private:
- StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
-
- public:
- const void* pNext = nullptr;
- XlibSurfaceCreateFlagsKHR flags;
- Display* dpy;
- Window window;
+ using layout::XlibSurfaceCreateInfoKHR::sType;
};
static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
+ static_assert( std::is_standard_layout<XlibSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d)
+ VULKAN_HPP_INLINE Result createInstance( const vk::InstanceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Instance* pInstance, Dispatch const &d)
{
return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
+ VULKAN_HPP_INLINE ResultValueType<vk::Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
{
- Instance instance;
+ vk::Instance instance;
Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" );
}
@@ -49514,7 +65391,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d )
{
- Instance instance;
+ vk::Instance instance;
Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
@@ -49524,7 +65401,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d)
+ VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d)
{
return static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
}
@@ -49576,7 +65453,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d)
+ VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d)
{
return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
}
@@ -49643,7 +65520,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result CommandBuffer::begin( const vk::CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( pBeginInfo ) ) );
}
@@ -49657,7 +65534,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const vk::ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
{
d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( pConditionalRenderingBegin ) );
}
@@ -49670,7 +65547,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
{
d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
}
@@ -49684,13 +65561,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginQuery( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d) const
{
d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginQuery( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d ) const
{
d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
}
@@ -49698,33 +65575,33 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d) const
{
d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d ) const
{
d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const vk::RenderPassBeginInfo* pRenderPassBegin, vk::SubpassContents contents, Dispatch const &d) const
{
d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, vk::SubpassContents contents, Dispatch const &d ) const
{
d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const vk::RenderPassBeginInfo* pRenderPassBegin, const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
{
d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ) );
}
@@ -49737,13 +65614,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
{
d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), reinterpret_cast<const VkDeviceSize*>( pCounterBufferOffsets ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
@@ -49758,13 +65635,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const
{
d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, ArrayProxy<const vk::DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d ) const
{
d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() );
}
@@ -49772,13 +65649,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d) const
{
d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d ) const
{
d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkIndexType>( indexType ) );
}
@@ -49786,13 +65663,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d) const
{
d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d ) const
{
d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
}
@@ -49800,26 +65677,26 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d) const
{
d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d ) const
{
d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, const vk::DeviceSize* pSizes, Dispatch const &d) const
{
d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), reinterpret_cast<const VkDeviceSize*>( pOffsets ), reinterpret_cast<const VkDeviceSize*>( pSizes ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, ArrayProxy<const DeviceSize> sizes, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, ArrayProxy<const vk::DeviceSize> sizes, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
@@ -49850,13 +65727,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer* pBuffers, const vk::DeviceSize* pOffsets, Dispatch const &d) const
{
d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), reinterpret_cast<const VkDeviceSize*>( pOffsets ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const vk::Buffer> buffers, ArrayProxy<const vk::DeviceSize> offsets, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
@@ -49871,65 +65748,65 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageBlit* pRegions, vk::Filter filter, Dispatch const &d) const
{
d.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 ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::blitImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageBlit> regions, vk::Filter filter, Dispatch const &d ) const
{
d.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 ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const vk::AccelerationStructureInfoNV* pInfo, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d) const
{
d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( pInfo ), static_cast<VkBuffer>( instanceData ), static_cast<VkDeviceSize>( instanceOffset ), static_cast<VkBool32>( update ), static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), static_cast<VkDeviceSize>( scratchOffset ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d ) const
{
d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( &info ), static_cast<VkBuffer>( instanceData ), static_cast<VkDeviceSize>( instanceOffset ), static_cast<VkBool32>( update ), static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), static_cast<VkDeviceSize>( scratchOffset ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const vk::ClearAttachment* pAttachments, uint32_t rectCount, const vk::ClearRect* pRects, Dispatch const &d) const
{
d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const vk::ClearAttachment> attachments, ArrayProxy<const vk::ClearRect> rects, Dispatch const &d ) const
{
d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue* pColor, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d) const
{
d.vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( pColor ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( vk::Image image, vk::ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d ) const
{
d.vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( &color ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const vk::ImageSubresourceRange* pRanges, Dispatch const &d) const
{
d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( pDepthStencil ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( vk::Image image, vk::ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const vk::ImageSubresourceRange> ranges, Dispatch const &d ) const
{
d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( &depthStencil ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
}
@@ -49937,65 +65814,65 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeNV mode, Dispatch const &d) const
{
d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeNV mode, Dispatch const &d ) const
{
d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferCopy* pRegions, Dispatch const &d) const
{
d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( vk::Buffer srcBuffer, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferCopy> regions, Dispatch const &d ) const
{
d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d) const
{
d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d ) const
{
d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageCopy* pRegions, Dispatch const &d) const
{
d.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 ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageCopy> regions, Dispatch const &d ) const
{
d.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() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferImageCopy* pRegions, Dispatch const &d) const
{
d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, ArrayProxy<const vk::BufferImageCopy> regions, Dispatch const &d ) const
{
d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
}
@@ -50003,20 +65880,20 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d) const
{
d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d ) const
{
d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
{
d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
}
@@ -50043,7 +65920,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const vk::DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d) const
{
d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
}
@@ -50099,13 +65976,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d) const
{
d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d ) const
{
d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
}
@@ -50141,13 +66018,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
@@ -50155,13 +66032,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
@@ -50169,13 +66046,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
@@ -50183,13 +66060,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
@@ -50197,13 +66074,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
{
d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), static_cast<VkDeviceSize>( counterBufferOffset ), counterOffset, vertexStride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
{
d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), static_cast<VkDeviceSize>( counterBufferOffset ), counterOffset, vertexStride );
}
@@ -50211,13 +66088,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
@@ -50225,13 +66102,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
@@ -50239,13 +66116,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), static_cast<VkBuffer>( countBuffer ), static_cast<VkDeviceSize>( countBufferOffset ), maxDrawCount, stride );
}
@@ -50253,13 +66130,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d) const
{
d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d ) const
{
d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
@@ -50309,13 +66186,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::endQuery( vk::QueryPool queryPool, uint32_t query, Dispatch const &d) const
{
d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::endQuery( vk::QueryPool queryPool, uint32_t query, Dispatch const &d ) const
{
d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
}
@@ -50323,13 +66200,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d) const
{
d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d ) const
{
d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
}
@@ -50350,7 +66227,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
{
d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
}
@@ -50363,13 +66240,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer* pCounterBuffers, const vk::DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
{
d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), reinterpret_cast<const VkDeviceSize*>( pCounterBufferOffsets ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const vk::Buffer> counterBuffers, ArrayProxy<const vk::DeviceSize> counterBufferOffsets, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
@@ -50384,13 +66261,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
{
d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d ) const
{
d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
}
@@ -50398,20 +66275,20 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d) const
{
d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d ) const
{
d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( size ), data );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
{
d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
}
@@ -50425,20 +66302,20 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( vk::SubpassContents contents, Dispatch const &d) const
{
d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( vk::SubpassContents contents, Dispatch const &d ) const
{
d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const vk::SubpassBeginInfoKHR* pSubpassBeginInfo, const vk::SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
{
d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
}
@@ -50451,20 +66328,20 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::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, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
{
d.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 ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
{
d.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() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const vk::CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
{
d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) );
}
@@ -50477,26 +66354,26 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
{
d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename T, typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::pushConstants( vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d ) const
{
d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
{
d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, Dispatch const &d ) const
{
d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
}
@@ -50504,20 +66381,20 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
{
d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
{
d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const vk::CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d) const
{
d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) );
}
@@ -50531,13 +66408,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::resetEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d) const
{
d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::resetEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d ) const
{
d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
}
@@ -50545,26 +66422,26 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
{
d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
{
d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageResolve* pRegions, Dispatch const &d) const
{
d.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 ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::resolveImage( vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, ArrayProxy<const vk::ImageResolve> regions, Dispatch const &d ) const
{
d.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() ) );
}
@@ -50599,13 +66476,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
{
d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( vk::CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const vk::CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d ) const
{
d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
}
@@ -50668,13 +66545,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const vk::Rect2D* pDiscardRectangles, Dispatch const &d) const
{
d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const vk::Rect2D> discardRectangles, Dispatch const &d ) const
{
d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
}
@@ -50682,26 +66559,26 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d) const
{
d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setEvent( vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d ) const
{
d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Rect2D* pExclusiveScissors, Dispatch const &d) const
{
d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const vk::Rect2D> exclusiveScissors, Dispatch const &d ) const
{
d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
}
@@ -50709,6 +66586,20 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d) const
+ {
+ d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern );
+ }
+#else
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d ) const
+ {
+ d.vkCmdSetLineStippleEXT( m_commandBuffer, lineStippleFactor, lineStipplePattern );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const
{
d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
@@ -50722,7 +66613,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const vk::PerformanceMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>( pMarkerInfo ) ) );
}
@@ -50736,7 +66627,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const vk::PerformanceOverrideInfoINTEL* pOverrideInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>( pOverrideInfo ) ) );
}
@@ -50750,7 +66641,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const vk::PerformanceStreamMarkerInfoINTEL* pMarkerInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>( pMarkerInfo ) ) );
}
@@ -50764,7 +66655,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const vk::SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
{
d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) );
}
@@ -50777,13 +66668,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const vk::Rect2D* pScissors, Dispatch const &d) const
{
d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const vk::Rect2D> scissors, Dispatch const &d ) const
{
d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
}
@@ -50791,13 +66682,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
{
d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
{
d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
}
@@ -50805,13 +66696,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d) const
{
d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d ) const
{
d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
}
@@ -50819,52 +66710,52 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
{
d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
{
d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const vk::Viewport* pViewports, Dispatch const &d) const
{
d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const vk::Viewport> viewports, Dispatch const &d ) const
{
d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
{
d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const vk::ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d ) const
{
d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
{
d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const vk::ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
{
d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
}
@@ -50872,52 +66763,52 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
{
d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), static_cast<VkDeviceSize>( raygenShaderBindingOffset ), static_cast<VkBuffer>( missShaderBindingTableBuffer ), static_cast<VkDeviceSize>( missShaderBindingOffset ), static_cast<VkDeviceSize>( missShaderBindingStride ), static_cast<VkBuffer>( hitShaderBindingTableBuffer ), static_cast<VkDeviceSize>( hitShaderBindingOffset ), static_cast<VkDeviceSize>( hitShaderBindingStride ), static_cast<VkBuffer>( callableShaderBindingTableBuffer ), static_cast<VkDeviceSize>( callableShaderBindingOffset ), static_cast<VkDeviceSize>( callableShaderBindingStride ), width, height, depth );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
{
d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), static_cast<VkDeviceSize>( raygenShaderBindingOffset ), static_cast<VkBuffer>( missShaderBindingTableBuffer ), static_cast<VkDeviceSize>( missShaderBindingOffset ), static_cast<VkDeviceSize>( missShaderBindingStride ), static_cast<VkBuffer>( hitShaderBindingTableBuffer ), static_cast<VkDeviceSize>( hitShaderBindingOffset ), static_cast<VkDeviceSize>( hitShaderBindingStride ), static_cast<VkBuffer>( callableShaderBindingTableBuffer ), static_cast<VkDeviceSize>( callableShaderBindingOffset ), static_cast<VkDeviceSize>( callableShaderBindingStride ), width, height, depth );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize dataSize, const void* pData, Dispatch const &d) const
{
d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( dataSize ), pData );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename T, typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( vk::Buffer dstBuffer, vk::DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
{
d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::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, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const vk::Event* pEvents, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const vk::MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
{
d.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 ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const vk::Event> events, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, ArrayProxy<const vk::MemoryBarrier> memoryBarriers, ArrayProxy<const vk::BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const vk::ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
{
d.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() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const vk::AccelerationStructureNV* pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const
{
d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureNV*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy<const vk::AccelerationStructureNV> accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d ) const
{
d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureNV*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
}
@@ -50925,13 +66816,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
{
d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
{
d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), static_cast<VkDeviceSize>( dstOffset ), marker );
}
@@ -50939,13 +66830,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const
+ VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d) const
{
d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d ) const
{
d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
}
@@ -50968,13 +66859,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result CommandBuffer::reset( vk::CommandBufferResetFlags flags, Dispatch const &d) const
{
return static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( vk::CommandBufferResetFlags flags, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" );
@@ -50984,13 +66875,13 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d) const
{
return static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireFullScreenExclusiveModeEXT" );
@@ -50999,7 +66890,7 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const vk::AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
{
return static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( pAcquireInfo ), pImageIndex ) );
}
@@ -51014,13 +66905,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
{
return static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, Dispatch const &d ) const
{
uint32_t imageIndex;
Result result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
@@ -51029,22 +66920,22 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const vk::PerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, vk::PerformanceConfigurationINTEL* pConfiguration, Dispatch const &d) const
{
return static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device, reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>( pAcquireInfo ), reinterpret_cast<VkPerformanceConfigurationINTEL*>( pConfiguration ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<PerformanceConfigurationINTEL>::type Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::PerformanceConfigurationINTEL>::type Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d ) const
{
- PerformanceConfigurationINTEL configuration;
+ vk::PerformanceConfigurationINTEL configuration;
Result result = static_cast<Result>( d.vkAcquirePerformanceConfigurationINTEL( m_device, reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>( &acquireInfo ), reinterpret_cast<VkPerformanceConfigurationINTEL*>( &configuration ) ) );
return createResultValue( result, configuration, VULKAN_HPP_NAMESPACE_STRING"::Device::acquirePerformanceConfigurationINTEL" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
{
return static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
}
@@ -51106,7 +66997,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const vk::DescriptorSetAllocateInfo* pAllocateInfo, vk::DescriptorSet* pDescriptorSets, Dispatch const &d) const
{
return static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
}
@@ -51168,15 +67059,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::allocateMemory( const vk::MemoryAllocateInfo* pAllocateInfo, const vk::AllocationCallbacks* pAllocator, vk::DeviceMemory* pMemory, Dispatch const &d) const
{
return static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( pAllocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDeviceMemory*>( pMemory ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DeviceMemory>::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DeviceMemory>::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DeviceMemory memory;
+ vk::DeviceMemory memory;
Result result = static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemory" );
}
@@ -51184,7 +67075,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DeviceMemory memory;
+ vk::DeviceMemory memory;
Result result = static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
ObjectFree<Device,Dispatch> deleter( *this, allocator, d );
@@ -51194,13 +67085,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const vk::BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindAccelerationStructureMemoryNV( ArrayProxy<const vk::BindAccelerationStructureMemoryInfoNV> bindInfos, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
@@ -51209,13 +67100,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" );
@@ -51223,13 +67114,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2" );
@@ -51237,13 +67128,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const vk::BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const vk::BindBufferMemoryInfo> bindInfos, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" );
@@ -51252,13 +67143,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" );
@@ -51266,13 +67157,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2" );
@@ -51280,13 +67171,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const vk::BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
{
return static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const vk::BindImageMemoryInfo> bindInfos, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" );
@@ -51295,13 +67186,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d) const
{
return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::compileDeferredNV( vk::Pipeline pipeline, uint32_t shader, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" );
@@ -51309,15 +67200,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const vk::AccelerationStructureCreateInfoNV* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNV*>( pAccelerationStructure ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::AccelerationStructureNV>::type Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- AccelerationStructureNV accelerationStructure;
+ vk::AccelerationStructureNV accelerationStructure;
Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" );
}
@@ -51325,7 +67216,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<AccelerationStructureNV,Dispatch>>::type Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- AccelerationStructureNV accelerationStructure;
+ vk::AccelerationStructureNV accelerationStructure;
Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51335,15 +67226,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createBuffer( const vk::BufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Buffer* pBuffer, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Buffer buffer;
+ vk::Buffer buffer;
Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" );
}
@@ -51351,7 +67242,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Buffer buffer;
+ vk::Buffer buffer;
Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51361,15 +67252,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createBufferView( const vk::BufferViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::BufferView* pView, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- BufferView view;
+ vk::BufferView view;
Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" );
}
@@ -51377,7 +67268,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- BufferView view;
+ vk::BufferView view;
Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51387,15 +67278,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createCommandPool( const vk::CommandPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::CommandPool* pCommandPool, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- CommandPool commandPool;
+ vk::CommandPool commandPool;
Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" );
}
@@ -51403,7 +67294,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- CommandPool commandPool;
+ vk::CommandPool commandPool;
Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51413,27 +67304,27 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createComputePipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ComputePipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( d.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() ) ) );
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
Result result = static_cast<Result>( d.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() ) ) );
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
}
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.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 ) ) );
@@ -51441,7 +67332,7 @@
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
@@ -51460,7 +67351,7 @@
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createComputePipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
@@ -51479,7 +67370,7 @@
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
}
template<typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createComputePipelineUnique( vk::PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.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 ) ) );
@@ -51491,15 +67382,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createDescriptorPool( const vk::DescriptorPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorPool* pDescriptorPool, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorPool descriptorPool;
+ vk::DescriptorPool descriptorPool;
Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" );
}
@@ -51507,7 +67398,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorPool,Dispatch>>::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorPool descriptorPool;
+ vk::DescriptorPool descriptorPool;
Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51517,15 +67408,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorSetLayout* pSetLayout, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorSetLayout setLayout;
+ vk::DescriptorSetLayout setLayout;
Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" );
}
@@ -51533,7 +67424,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorSetLayout,Dispatch>>::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorSetLayout setLayout;
+ vk::DescriptorSetLayout setLayout;
Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51543,15 +67434,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorUpdateTemplate descriptorUpdateTemplate;
+ vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplate" );
}
@@ -51559,7 +67450,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorUpdateTemplate descriptorUpdateTemplate;
+ vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51569,15 +67460,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const vk::DescriptorUpdateTemplateCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DescriptorUpdateTemplate>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorUpdateTemplate descriptorUpdateTemplate;
+ vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" );
}
@@ -51585,7 +67476,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DescriptorUpdateTemplate,Dispatch>>::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DescriptorUpdateTemplate descriptorUpdateTemplate;
+ vk::DescriptorUpdateTemplate descriptorUpdateTemplate;
Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51595,15 +67486,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createEvent( const vk::EventCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Event* pEvent, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Event event;
+ vk::Event event;
Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" );
}
@@ -51611,7 +67502,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Event,Dispatch>>::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Event event;
+ vk::Event event;
Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51621,15 +67512,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createFence( const vk::FenceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Fence fence;
+ vk::Fence fence;
Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" );
}
@@ -51637,7 +67528,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Fence fence;
+ vk::Fence fence;
Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51647,15 +67538,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createFramebuffer( const vk::FramebufferCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Framebuffer* pFramebuffer, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Framebuffer framebuffer;
+ vk::Framebuffer framebuffer;
Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" );
}
@@ -51663,7 +67554,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Framebuffer framebuffer;
+ vk::Framebuffer framebuffer;
Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51673,27 +67564,27 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::GraphicsPipelineCreateInfo* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( d.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() ) ) );
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
Result result = static_cast<Result>( d.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() ) ) );
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
}
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.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 ) ) );
@@ -51701,7 +67592,7 @@
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
@@ -51720,7 +67611,7 @@
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createGraphicsPipelinesUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
@@ -51739,7 +67630,7 @@
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
}
template<typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createGraphicsPipelineUnique( vk::PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.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 ) ) );
@@ -51751,15 +67642,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createImage( const vk::ImageCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Image* pImage, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Image image;
+ vk::Image image;
Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" );
}
@@ -51767,7 +67658,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Image,Dispatch>>::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Image image;
+ vk::Image image;
Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51777,15 +67668,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createImageView( const vk::ImageViewCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ImageView* pView, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ImageView view;
+ vk::ImageView view;
Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" );
}
@@ -51793,7 +67684,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ImageView view;
+ vk::ImageView view;
Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51803,15 +67694,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const vk::IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- IndirectCommandsLayoutNVX indirectCommandsLayout;
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" );
}
@@ -51819,7 +67710,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<IndirectCommandsLayoutNVX,Dispatch>>::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- IndirectCommandsLayoutNVX indirectCommandsLayout;
+ vk::IndirectCommandsLayoutNVX indirectCommandsLayout;
Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51829,15 +67720,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const vk::ObjectTableCreateInfoNVX* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ObjectTableNVX* pObjectTable, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ObjectTableNVX objectTable;
+ vk::ObjectTableNVX objectTable;
Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" );
}
@@ -51845,7 +67736,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ObjectTableNVX,Dispatch>>::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ObjectTableNVX objectTable;
+ vk::ObjectTableNVX objectTable;
Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51855,15 +67746,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createPipelineCache( const vk::PipelineCacheCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineCache* pPipelineCache, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- PipelineCache pipelineCache;
+ vk::PipelineCache pipelineCache;
Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" );
}
@@ -51871,7 +67762,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineCache,Dispatch>>::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- PipelineCache pipelineCache;
+ vk::PipelineCache pipelineCache;
Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51881,15 +67772,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createPipelineLayout( const vk::PipelineLayoutCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::PipelineLayout* pPipelineLayout, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- PipelineLayout pipelineLayout;
+ vk::PipelineLayout pipelineLayout;
Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" );
}
@@ -51897,7 +67788,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<PipelineLayout,Dispatch>>::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- PipelineLayout pipelineLayout;
+ vk::PipelineLayout pipelineLayout;
Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51907,15 +67798,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createQueryPool( const vk::QueryPoolCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::QueryPool* pQueryPool, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- QueryPool queryPool;
+ vk::QueryPool queryPool;
Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" );
}
@@ -51923,7 +67814,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- QueryPool queryPool;
+ vk::QueryPool queryPool;
Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -51933,27 +67824,27 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoNV* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::Pipeline* pPipelines, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createRayTracingPipelinesNV( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
}
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createRayTracingPipelineNV( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -51961,7 +67852,7 @@
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines;
@@ -51980,7 +67871,7 @@
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, ArrayProxy<const RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<Pipeline,Dispatch>,Allocator>>::type Device::createRayTracingPipelinesNVUnique( vk::PipelineCache pipelineCache, ArrayProxy<const vk::RayTracingPipelineCreateInfoNV> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
static_assert( sizeof( Pipeline ) <= sizeof( UniqueHandle<Pipeline, Dispatch> ), "Pipeline is greater than UniqueHandle<Pipeline, Dispatch>!" );
std::vector<UniqueHandle<Pipeline, Dispatch>, Allocator> pipelines( vectorAllocator );
@@ -51999,7 +67890,7 @@
return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
}
template<typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type Device::createRayTracingPipelineNVUnique( vk::PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
Pipeline pipeline;
Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
@@ -52011,15 +67902,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createRenderPass( const vk::RenderPassCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- RenderPass renderPass;
+ vk::RenderPass renderPass;
Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" );
}
@@ -52027,7 +67918,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- RenderPass renderPass;
+ vk::RenderPass renderPass;
Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52037,15 +67928,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const vk::RenderPassCreateInfo2KHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::RenderPass* pRenderPass, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::RenderPass>::type Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- RenderPass renderPass;
+ vk::RenderPass renderPass;
Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
}
@@ -52053,7 +67944,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- RenderPass renderPass;
+ vk::RenderPass renderPass;
Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52063,15 +67954,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createSampler( const vk::SamplerCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Sampler* pSampler, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Sampler sampler;
+ vk::Sampler sampler;
Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" );
}
@@ -52079,7 +67970,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Sampler sampler;
+ vk::Sampler sampler;
Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52089,15 +67980,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SamplerYcbcrConversion ycbcrConversion;
+ vk::SamplerYcbcrConversion ycbcrConversion;
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversion" );
}
@@ -52105,7 +67996,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SamplerYcbcrConversion ycbcrConversion;
+ vk::SamplerYcbcrConversion ycbcrConversion;
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52115,15 +68006,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const vk::SamplerYcbcrConversionCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SamplerYcbcrConversion>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SamplerYcbcrConversion ycbcrConversion;
+ vk::SamplerYcbcrConversion ycbcrConversion;
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" );
}
@@ -52131,7 +68022,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SamplerYcbcrConversion,Dispatch>>::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SamplerYcbcrConversion ycbcrConversion;
+ vk::SamplerYcbcrConversion ycbcrConversion;
Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52141,15 +68032,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createSemaphore( const vk::SemaphoreCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Semaphore* pSemaphore, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Semaphore semaphore;
+ vk::Semaphore semaphore;
Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" );
}
@@ -52157,7 +68048,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Semaphore semaphore;
+ vk::Semaphore semaphore;
Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52167,15 +68058,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createShaderModule( const vk::ShaderModuleCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ShaderModule* pShaderModule, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ShaderModule shaderModule;
+ vk::ShaderModule shaderModule;
Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" );
}
@@ -52183,7 +68074,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ShaderModule,Dispatch>>::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ShaderModule shaderModule;
+ vk::ShaderModule shaderModule;
Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52193,20 +68084,20 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const vk::SwapchainCreateInfoKHR* pCreateInfos, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchains, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
Result result = static_cast<Result>( d.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() ) ) );
return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size(), vectorAllocator );
Result result = static_cast<Result>( d.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() ) ) );
@@ -52221,7 +68112,7 @@
}
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs;
@@ -52240,7 +68131,7 @@
return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR,Dispatch>,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const vk::SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const
{
static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueHandle<SwapchainKHR, Dispatch> ), "SwapchainKHR is greater than UniqueHandle<SwapchainKHR, Dispatch>!" );
std::vector<UniqueHandle<SwapchainKHR, Dispatch>, Allocator> swapchainKHRs( vectorAllocator );
@@ -52271,15 +68162,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const vk::SwapchainCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SwapchainKHR* pSwapchain, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SwapchainKHR swapchain;
+ vk::SwapchainKHR swapchain;
Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" );
}
@@ -52287,7 +68178,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SwapchainKHR,Dispatch>>::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SwapchainKHR swapchain;
+ vk::SwapchainKHR swapchain;
Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52297,15 +68188,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const vk::ValidationCacheCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::ValidationCacheEXT* pValidationCache, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ValidationCacheEXT validationCache;
+ vk::ValidationCacheEXT validationCache;
Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" );
}
@@ -52313,7 +68204,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<ValidationCacheEXT,Dispatch>>::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- ValidationCacheEXT validationCache;
+ vk::ValidationCacheEXT validationCache;
Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
@@ -52323,7 +68214,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const vk::DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
}
@@ -52337,7 +68228,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const vk::DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
}
@@ -52351,202 +68242,202 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyBuffer( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyBuffer( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Buffer buffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Buffer buffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyBufferView( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyBufferView( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::BufferView bufferView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyCommandPool( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyCommandPool( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::CommandPool commandPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorPool( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorPool( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
@@ -52559,481 +68450,481 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyEvent( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyEvent( vk::Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Event event, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Event event, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyFence( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyFence( vk::Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Fence fence, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyFramebuffer( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyFramebuffer( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Framebuffer framebuffer, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyImage( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyImage( vk::Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Image image, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Image image, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyImageView( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyImageView( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ImageView imageView, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ObjectTableNVX objectTable, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyPipeline( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyPipeline( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Pipeline pipeline, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyPipelineCache( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyPipelineCache( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::PipelineCache pipelineCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyPipelineLayout( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyPipelineLayout( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyQueryPool( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyQueryPool( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::QueryPool queryPool, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyRenderPass( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyRenderPass( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::RenderPass renderPass, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroySampler( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroySampler( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Sampler sampler, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Sampler sampler, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( vk::SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroySemaphore( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroySemaphore( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Semaphore semaphore, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyShaderModule( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyShaderModule( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ShaderModule shaderModule, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroySwapchainKHR( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroySwapchainKHR( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::SwapchainKHR swapchain, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::destroy( vk::ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
@@ -53055,13 +68946,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( vk::DisplayKHR display, const vk::DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( vk::DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" );
@@ -53069,13 +68960,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
{
return static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" );
@@ -53083,39 +68974,39 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::freeCommandBuffers( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
{
d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::freeCommandBuffers( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d ) const
{
d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::free( vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
{
d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::free( vk::CommandPool commandPool, ArrayProxy<const vk::CommandBuffer> commandBuffers, Dispatch const &d ) const
{
d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::freeDescriptorSets( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d) const
{
return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" );
@@ -53123,13 +69014,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::free( vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet* pDescriptorSets, Dispatch const &d) const
{
return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::free( vk::DescriptorPool descriptorPool, ArrayProxy<const vk::DescriptorSet> descriptorSets, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" );
@@ -53137,39 +69028,39 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::freeMemory( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::freeMemory( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::free( vk::DeviceMemory memory, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::free( vk::DeviceMemory memory, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename T, typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::getAccelerationStructureHandleNV( vk::AccelerationStructureNV accelerationStructure, ArrayProxy<T> data, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
@@ -53177,15 +69068,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const vk::AccelerationStructureMemoryRequirementsInfoNV* pInfo, vk::MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
{
- MemoryRequirements2KHR memoryRequirements;
+ vk::MemoryRequirements2KHR memoryRequirements;
d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
return memoryRequirements;
}
@@ -53193,7 +69084,7 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>();
+ vk::MemoryRequirements2KHR& memoryRequirements = structureChain.template get<vk::MemoryRequirements2KHR>();
d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
return structureChain;
}
@@ -53201,15 +69092,15 @@
#ifdef VK_USE_PLATFORM_ANDROID_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, vk::AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( pProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
{
- AndroidHardwareBufferPropertiesANDROID properties;
+ vk::AndroidHardwareBufferPropertiesANDROID properties;
Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
}
@@ -53217,7 +69108,7 @@
VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
+ vk::AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<vk::AndroidHardwareBufferPropertiesANDROID>();
Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
}
@@ -53225,7 +69116,7 @@
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const vk::BufferDeviceAddressInfoEXT* pInfo, Dispatch const &d) const
{
return static_cast<DeviceAddress>( d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast<const VkBufferDeviceAddressInfoEXT*>( pInfo ) ) );
}
@@ -53238,30 +69129,30 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( vk::Buffer buffer, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements Device::getBufferMemoryRequirements( vk::Buffer buffer, Dispatch const &d ) const
{
- MemoryRequirements memoryRequirements;
+ vk::MemoryRequirements memoryRequirements;
d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
return memoryRequirements;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- MemoryRequirements2 memoryRequirements;
+ vk::MemoryRequirements2 memoryRequirements;
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
@@ -53269,22 +69160,22 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+ vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const vk::BufferMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- MemoryRequirements2 memoryRequirements;
+ vk::MemoryRequirements2 memoryRequirements;
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
@@ -53292,20 +69183,20 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+ vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const vk::CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT( ArrayProxy<const vk::CalibratedTimestampInfoEXT> timestampInfos, ArrayProxy<uint64_t> timestamps, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
@@ -53322,15 +69213,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
{
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
{
- DescriptorSetLayoutSupport support;
+ vk::DescriptorSetLayoutSupport support;
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return support;
}
@@ -53338,22 +69229,22 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
+ vk::DescriptorSetLayoutSupport& support = structureChain.template get<vk::DescriptorSetLayoutSupport>();
d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const vk::DescriptorSetLayoutCreateInfo* pCreateInfo, vk::DescriptorSetLayoutSupport* pSupport, Dispatch const &d) const
{
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
{
- DescriptorSetLayoutSupport support;
+ vk::DescriptorSetLayoutSupport support;
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return support;
}
@@ -53361,52 +69252,52 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
+ vk::DescriptorSetLayoutSupport& support = structureChain.template get<vk::DescriptorSetLayoutSupport>();
d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
{
d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
{
- PeerMemoryFeatureFlags peerMemoryFeatures;
+ vk::PeerMemoryFeatureFlags peerMemoryFeatures;
d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
return peerMemoryFeatures;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
{
d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
{
- PeerMemoryFeatureFlags peerMemoryFeatures;
+ vk::PeerMemoryFeatureFlags peerMemoryFeatures;
d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
return peerMemoryFeatures;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( vk::DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( pDeviceGroupPresentCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHR>::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DeviceGroupPresentCapabilitiesKHR>::type Device::getGroupPresentCapabilitiesKHR(Dispatch const &d ) const
{
- DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
+ vk::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( &deviceGroupPresentCapabilities ) ) );
return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" );
}
@@ -53414,15 +69305,15 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
{
- DeviceGroupPresentModeFlagsKHR modes;
+ vk::DeviceGroupPresentModeFlagsKHR modes;
Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModes2EXT" );
}
@@ -53430,30 +69321,30 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, vk::DeviceGroupPresentModeFlagsKHR* pModes, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DeviceGroupPresentModeFlagsKHR>::type Device::getGroupSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
{
- DeviceGroupPresentModeFlagsKHR modes;
+ vk::DeviceGroupPresentModeFlagsKHR modes;
Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getMemoryCommitment( vk::DeviceMemory memory, vk::DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
{
d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize*>( pCommittedMemoryInBytes ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::DeviceSize Device::getMemoryCommitment( vk::DeviceMemory memory, Dispatch const &d ) const
{
- DeviceSize committedMemoryInBytes;
+ vk::DeviceSize committedMemoryInBytes;
d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<VkDeviceSize*>( &committedMemoryInBytes ) );
return committedMemoryInBytes;
}
@@ -53473,30 +69364,30 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, vk::Queue* pQueue, Dispatch const &d) const
{
d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
{
- Queue queue;
+ vk::Queue queue;
d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
return queue;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getQueue2( const vk::DeviceQueueInfo2* pQueueInfo, vk::Queue* pQueue, Dispatch const &d) const
{
d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( pQueueInfo ), reinterpret_cast<VkQueue*>( pQueue ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
{
- Queue queue;
+ vk::Queue queue;
d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( &queueInfo ), reinterpret_cast<VkQueue*>( &queue ) );
return queue;
}
@@ -53504,13 +69395,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getEventStatus( vk::Event event, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const &d ) const
+ VULKAN_HPP_INLINE Result Device::getEventStatus( vk::Event event, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
@@ -53518,7 +69409,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const vk::FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
}
@@ -53534,13 +69425,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getFenceStatus( vk::Fence fence, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d ) const
+ VULKAN_HPP_INLINE Result Device::getFenceStatus( vk::Fence fence, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
@@ -53549,7 +69440,7 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const vk::FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
}
@@ -53565,45 +69456,45 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( vk::Image image, vk::ImageDrmFormatModifierPropertiesEXT* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( pProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ImageDrmFormatModifierPropertiesEXT>::type Device::getImageDrmFormatModifierPropertiesEXT( vk::Image image, Dispatch const &d ) const
{
- ImageDrmFormatModifierPropertiesEXT properties;
+ vk::ImageDrmFormatModifierPropertiesEXT properties;
Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( &properties ) ) );
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( vk::Image image, vk::MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements Device::getImageMemoryRequirements( vk::Image image, Dispatch const &d ) const
{
- MemoryRequirements memoryRequirements;
+ vk::MemoryRequirements memoryRequirements;
d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
return memoryRequirements;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- MemoryRequirements2 memoryRequirements;
+ vk::MemoryRequirements2 memoryRequirements;
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
@@ -53611,22 +69502,22 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+ vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const vk::ImageMemoryRequirementsInfo2* pInfo, vk::MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
{
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
- MemoryRequirements2 memoryRequirements;
+ vk::MemoryRequirements2 memoryRequirements;
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return memoryRequirements;
}
@@ -53634,20 +69525,20 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
+ vk::MemoryRequirements2& memoryRequirements = structureChain.template get<vk::MemoryRequirements2>();
d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( vk::Image image, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
{
d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const
+ VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( vk::Image image, Dispatch const &d ) const
{
std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
@@ -53657,7 +69548,7 @@
return sparseMemoryRequirements;
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( vk::Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements( vectorAllocator );
uint32_t sparseMemoryRequirementCount;
@@ -53669,7 +69560,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
{
d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
}
@@ -53697,7 +69588,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const vk::ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
{
d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
}
@@ -53725,22 +69616,22 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( vk::Image image, const vk::ImageSubresource* pSubresource, vk::SubresourceLayout* pLayout, Dispatch const &d) const
{
d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::SubresourceLayout Device::getImageSubresourceLayout( vk::Image image, const ImageSubresource & subresource, Dispatch const &d ) const
{
- SubresourceLayout layout;
+ vk::SubresourceLayout layout;
d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
return layout;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX* pInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const vk::ImageViewHandleInfoNVX* pInfo, Dispatch const &d) const
{
return d.vkGetImageViewHandleNVX( m_device, reinterpret_cast<const VkImageViewHandleInfoNVX*>( pInfo ) );
}
@@ -53754,7 +69645,7 @@
#ifdef VK_USE_PLATFORM_ANDROID_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const vk::MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( pInfo ), pBuffer ) );
}
@@ -53770,7 +69661,7 @@
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const vk::MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
}
@@ -53785,30 +69676,30 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, vk::MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d ) const
{
- MemoryFdPropertiesKHR memoryFdProperties;
+ vk::MemoryFdPropertiesKHR memoryFdProperties;
Result result = static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) );
return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, vk::MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( vk::ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, Dispatch const &d ) const
{
- MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
+ vk::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" );
}
@@ -53816,7 +69707,7 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const vk::MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
}
@@ -53833,13 +69724,13 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( vk::DeviceMemory memory, vk::ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
{
HANDLE handle;
Result result = static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
@@ -53850,15 +69741,15 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, vk::MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( vk::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
{
- MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
+ vk::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) );
return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" );
}
@@ -53866,13 +69757,13 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, vk::PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d ) const
{
std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
uint32_t presentationTimingCount;
@@ -53894,7 +69785,7 @@
return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings( vectorAllocator );
uint32_t presentationTimingCount;
@@ -53918,28 +69809,28 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, PerformanceValueINTEL* pValue, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, vk::PerformanceValueINTEL* pValue, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL*>( pValue ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<PerformanceValueINTEL>::type Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::PerformanceValueINTEL>::type Device::getPerformanceParameterINTEL( vk::PerformanceParameterTypeINTEL parameter, Dispatch const &d ) const
{
- PerformanceValueINTEL value;
+ vk::PerformanceValueINTEL value;
Result result = static_cast<Result>( d.vkGetPerformanceParameterINTEL( m_device, static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL*>( &value ) ) );
return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING"::Device::getPerformanceParameterINTEL" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getPipelineCacheData( vk::PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( vk::PipelineCache pipelineCache, Dispatch const &d ) const
{
std::vector<uint8_t,Allocator> data;
size_t dataSize;
@@ -53961,7 +69852,7 @@
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( vk::PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<uint8_t,Allocator> data( vectorAllocator );
size_t dataSize;
@@ -53985,13 +69876,169 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getPipelineExecutableInternalRepresentationsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR* pInternalRepresentations, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( pExecutableInfo ), pInternalRepresentationCount, reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( pInternalRepresentations ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d ) const
+ {
+ std::vector<PipelineExecutableInternalRepresentationKHR,Allocator> internalRepresentations;
+ uint32_t internalRepresentationCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && internalRepresentationCount )
+ {
+ internalRepresentations.resize( internalRepresentationCount );
+ result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( internalRepresentations.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+ internalRepresentations.resize( internalRepresentationCount );
+ }
+ return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableInternalRepresentationsKHR" );
+ }
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,Allocator>>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PipelineExecutableInternalRepresentationKHR,Allocator> internalRepresentations( vectorAllocator );
+ uint32_t internalRepresentationCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && internalRepresentationCount )
+ {
+ internalRepresentations.resize( internalRepresentationCount );
+ result = static_cast<Result>( d.vkGetPipelineExecutableInternalRepresentationsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &internalRepresentationCount, reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( internalRepresentations.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
+ internalRepresentations.resize( internalRepresentationCount );
+ }
+ return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableInternalRepresentationsKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const vk::PipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, vk::PipelineExecutablePropertiesKHR* pProperties, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( pPipelineInfo ), pExecutableCount, reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( pProperties ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const &d ) const
+ {
+ std::vector<PipelineExecutablePropertiesKHR,Allocator> properties;
+ uint32_t executableCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && executableCount )
+ {
+ properties.resize( executableCount );
+ result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( executableCount <= properties.size() );
+ properties.resize( executableCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutablePropertiesKHR" );
+ }
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutablePropertiesKHR,Allocator>>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PipelineExecutablePropertiesKHR,Allocator> properties( vectorAllocator );
+ uint32_t executableCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && executableCount )
+ {
+ properties.resize( executableCount );
+ result = static_cast<Result>( d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast<const VkPipelineInfoKHR*>( &pipelineInfo ), &executableCount, reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( properties.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( executableCount <= properties.size() );
+ properties.resize( executableCount );
+ }
+ return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutablePropertiesKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getPipelineExecutableStatisticsKHR( const vk::PipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, vk::PipelineExecutableStatisticKHR* pStatistics, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( pExecutableInfo ), pStatisticCount, reinterpret_cast<VkPipelineExecutableStatisticKHR*>( pStatistics ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const &d ) const
+ {
+ std::vector<PipelineExecutableStatisticKHR,Allocator> statistics;
+ uint32_t statisticCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && statisticCount )
+ {
+ statistics.resize( statisticCount );
+ result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, reinterpret_cast<VkPipelineExecutableStatisticKHR*>( statistics.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
+ statistics.resize( statisticCount );
+ }
+ return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableStatisticsKHR" );
+ }
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PipelineExecutableStatisticKHR,Allocator>>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PipelineExecutableStatisticKHR,Allocator> statistics( vectorAllocator );
+ uint32_t statisticCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && statisticCount )
+ {
+ statistics.resize( statisticCount );
+ result = static_cast<Result>( d.vkGetPipelineExecutableStatisticsKHR( m_device, reinterpret_cast<const VkPipelineExecutableInfoKHR*>( &executableInfo ), &statisticCount, reinterpret_cast<VkPipelineExecutableStatisticKHR*>( statistics.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ if ( result == Result::eSuccess )
+ {
+ VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
+ statistics.resize( statisticCount );
+ }
+ return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineExecutableStatisticsKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename T, typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE Result Device::getQueryPoolResults( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), static_cast<VkDeviceSize>( stride ), static_cast<VkQueryResultFlags>( flags ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
@@ -53999,13 +70046,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename T, typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::getRayTracingShaderGroupHandlesNV( vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
@@ -54013,37 +70060,52 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, vk::RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( vk::SwapchainKHR swapchain, Dispatch const &d ) const
{
- RefreshCycleDurationGOOGLE displayTimingProperties;
+ vk::RefreshCycleDurationGOOGLE displayTimingProperties;
Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) );
return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( vk::RenderPass renderPass, vk::Extent2D* pGranularity, Dispatch const &d) const
{
d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::Extent2D Device::getRenderAreaGranularity( vk::RenderPass renderPass, Dispatch const &d ) const
{
- Extent2D granularity;
+ vk::Extent2D granularity;
d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
return granularity;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( vk::Semaphore semaphore, uint64_t* pValue, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), pValue ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSemaphoreCounterValueKHR( vk::Semaphore semaphore, Dispatch const &d ) const
+ {
+ uint64_t value;
+ Result result = static_cast<Result>( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast<VkSemaphore>( semaphore ), &value ) );
+ return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreCounterValueKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const vk::SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
}
@@ -54059,7 +70121,7 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const vk::SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
}
@@ -54075,13 +70137,13 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), pInfoSize, pInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Dispatch const &d ) const
{
std::vector<uint8_t,Allocator> info;
size_t infoSize;
@@ -54103,7 +70165,7 @@
return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<uint8_t,Allocator> info( vectorAllocator );
size_t infoSize;
@@ -54127,13 +70189,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<uint64_t>::type Device::getSwapchainCounterEXT( vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, Dispatch const &d ) const
{
uint64_t counterValue;
Result result = static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
@@ -54142,13 +70204,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( vk::SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, vk::Image* pSwapchainImages, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Dispatch const &d ) const
{
std::vector<Image,Allocator> swapchainImages;
uint32_t swapchainImageCount;
@@ -54170,7 +70232,7 @@
return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( vk::SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<Image,Allocator> swapchainImages( vectorAllocator );
uint32_t swapchainImageCount;
@@ -54195,13 +70257,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( vk::SwapchainKHR swapchain, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d ) const
+ VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( vk::SwapchainKHR swapchain, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
@@ -54209,13 +70271,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Dispatch const &d ) const
{
std::vector<uint8_t,Allocator> data;
size_t dataSize;
@@ -54237,7 +70299,7 @@
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( vk::ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<uint8_t,Allocator> data( vectorAllocator );
size_t dataSize;
@@ -54261,7 +70323,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const vk::ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) );
}
@@ -54276,7 +70338,7 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const vk::ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) );
}
@@ -54291,7 +70353,7 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const vk::ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) );
}
@@ -54306,7 +70368,7 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const vk::ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) );
}
@@ -54321,7 +70383,7 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const vk::InitializePerformanceApiInfoINTEL* pInitializeInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>( pInitializeInfo ) ) );
}
@@ -54335,13 +70397,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const vk::MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
{
return static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const vk::MappedMemoryRange> memoryRanges, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" );
@@ -54349,13 +70411,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, void** ppData, Dispatch const &d) const
{
return static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( offset ), static_cast<VkDeviceSize>( size ), static_cast<VkMemoryMapFlags>( flags ), ppData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, Dispatch const &d ) const
{
void* pData;
Result result = static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( offset ), static_cast<VkDeviceSize>( size ), static_cast<VkMemoryMapFlags>( flags ), &pData ) );
@@ -54364,13 +70426,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::mergePipelineCaches( vk::PipelineCache dstCache, uint32_t srcCacheCount, const vk::PipelineCache* pSrcCaches, Dispatch const &d) const
{
return static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( vk::PipelineCache dstCache, ArrayProxy<const vk::PipelineCache> srcCaches, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" );
@@ -54378,13 +70440,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const vk::ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
{
return static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( vk::ValidationCacheEXT dstCache, ArrayProxy<const vk::ValidationCacheEXT> srcCaches, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" );
@@ -54392,43 +70454,43 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::registerEventEXT( const vk::DeviceEventInfoEXT* pDeviceEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d) const
{
return static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Fence fence;
+ vk::Fence fence;
Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( vk::DisplayKHR display, const vk::DisplayEventInfoEXT* pDisplayEventInfo, const vk::AllocationCallbacks* pAllocator, vk::Fence* pFence, Dispatch const &d) const
{
return static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Fence>::type Device::registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Fence fence;
+ vk::Fence fence;
Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::registerObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
{
return static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() );
@@ -54446,13 +70508,13 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d) const
{
return static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::releaseFullScreenExclusiveModeEXT( vk::SwapchainKHR swapchain, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releaseFullScreenExclusiveModeEXT" );
@@ -54462,13 +70524,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d) const
{
return static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::releasePerformanceConfigurationINTEL" );
@@ -54477,13 +70539,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d) const
{
return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" );
@@ -54492,13 +70554,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags, Dispatch const &d) const
{
return static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" );
@@ -54507,13 +70569,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::resetEvent( vk::Event event, Dispatch const &d) const
{
return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( vk::Event event, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" );
@@ -54521,13 +70583,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const vk::Fence* pFences, Dispatch const &d) const
{
return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> fences, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const vk::Fence> fences, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" );
@@ -54536,20 +70598,20 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
{
d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::resetQueryPoolEXT( vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
{
d.vkResetQueryPoolEXT( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const vk::DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( pNameInfo ) ) );
}
@@ -54563,7 +70625,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const vk::DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( pTagInfo ) ) );
}
@@ -54578,13 +70640,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::setEvent( vk::Event event, Dispatch const &d) const
{
return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( Event event, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( vk::Event event, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" );
@@ -54592,13 +70654,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const vk::SwapchainKHR* pSwapchains, const vk::HdrMetadataEXT* pMetadata, Dispatch const &d) const
{
d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const vk::SwapchainKHR> swapchains, ArrayProxy<const vk::HdrMetadataEXT> metadata, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
@@ -54614,27 +70676,41 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d) const
{
d.vkSetLocalDimmingAMD( m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d ) const
{
d.vkSetLocalDimmingAMD( m_device, static_cast<VkSwapchainKHR>( swapChain ), static_cast<VkBool32>( localDimmingEnable ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const vk::SemaphoreSignalInfoKHR* pSignalInfo, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfoKHR*>( pSignalInfo ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::signalSemaphoreKHR( const SemaphoreSignalInfoKHR & signalInfo, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast<const VkSemaphoreSignalInfoKHR*>( &signalInfo ) ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::signalSemaphoreKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::trimCommandPool( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d) const
{
d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::trimCommandPool( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d ) const
{
d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
}
@@ -54642,13 +70718,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d) const
{
d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d ) const
{
d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
}
@@ -54670,26 +70746,26 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::unmapMemory( vk::DeviceMemory memory, Dispatch const &d) const
{
d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::unmapMemory( vk::DeviceMemory memory, Dispatch const &d ) const
{
d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( vk::ObjectTableNVX objectTable, uint32_t objectCount, const vk::ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
{
return static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( vk::ObjectTableNVX objectTable, ArrayProxy<const vk::ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() );
@@ -54706,13 +70782,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
{
d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
{
d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
}
@@ -54720,56 +70796,70 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
{
d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
{
d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const vk::WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const vk::CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
{
d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const vk::WriteDescriptorSet> descriptorWrites, ArrayProxy<const vk::CopyDescriptorSet> descriptorCopies, Dispatch const &d ) const
{
d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const vk::Fence* pFences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
{
return static_cast<Result>( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), static_cast<VkBool32>( waitAll ), timeout ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const
+ VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const vk::Fence> fences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const vk::SemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfoKHR*>( pWaitInfo ), timeout ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfoKHR & waitInfo, uint64_t timeout, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast<const VkSemaphoreWaitInfoKHR*>( &waitInfo ), timeout ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
#ifdef VK_USE_PLATFORM_ANDROID_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const vk::AndroidSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHR" );
}
@@ -54777,7 +70867,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54788,15 +70878,15 @@
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const vk::DebugReportCallbackCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugReportCallbackEXT* pCallback, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DebugReportCallbackEXT callback;
+ vk::DebugReportCallbackEXT callback;
Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" );
}
@@ -54804,7 +70894,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugReportCallbackEXT,Dispatch>>::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DebugReportCallbackEXT callback;
+ vk::DebugReportCallbackEXT callback;
Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54814,15 +70904,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const vk::DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DebugUtilsMessengerEXT* pMessenger, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( pMessenger ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DebugUtilsMessengerEXT>::type Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DebugUtilsMessengerEXT messenger;
+ vk::DebugUtilsMessengerEXT messenger;
Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" );
}
@@ -54830,7 +70920,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<DebugUtilsMessengerEXT,Dispatch>>::type Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DebugUtilsMessengerEXT messenger;
+ vk::DebugUtilsMessengerEXT messenger;
Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54840,15 +70930,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const vk::DisplaySurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHR" );
}
@@ -54856,7 +70946,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54866,15 +70956,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const vk::HeadlessSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createHeadlessSurfaceEXT" );
}
@@ -54882,7 +70972,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54893,15 +70983,15 @@
#ifdef VK_USE_PLATFORM_IOS_MVK
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const vk::IOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" );
}
@@ -54909,7 +70999,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54921,15 +71011,15 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const vk::ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" );
}
@@ -54937,7 +71027,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54949,15 +71039,15 @@
#ifdef VK_USE_PLATFORM_MACOS_MVK
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const vk::MacOSSurfaceCreateInfoMVK* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" );
}
@@ -54965,7 +71055,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -54977,15 +71067,15 @@
#ifdef VK_USE_PLATFORM_METAL_EXT
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const vk::MetalSurfaceCreateInfoEXT* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMetalSurfaceEXT" );
}
@@ -54993,7 +71083,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55005,15 +71095,15 @@
#ifdef VK_USE_PLATFORM_GGP
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const vk::StreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createStreamDescriptorSurfaceGGP" );
}
@@ -55021,7 +71111,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55033,15 +71123,15 @@
#ifdef VK_USE_PLATFORM_VI_NN
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const vk::ViSurfaceCreateInfoNN* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNN" );
}
@@ -55049,7 +71139,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55061,15 +71151,15 @@
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const vk::WaylandSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHR" );
}
@@ -55077,7 +71167,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55089,15 +71179,15 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const vk::Win32SurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHR" );
}
@@ -55105,7 +71195,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55117,15 +71207,15 @@
#ifdef VK_USE_PLATFORM_XCB_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const vk::XcbSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHR" );
}
@@ -55133,7 +71223,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55145,15 +71235,15 @@
#ifdef VK_USE_PLATFORM_XLIB_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const vk::XlibSurfaceCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::SurfaceKHR* pSurface, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" );
}
@@ -55161,7 +71251,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- SurfaceKHR surface;
+ vk::SurfaceKHR surface;
Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
@@ -55172,13 +71262,13 @@
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
{
d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d ) const
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() );
@@ -55193,59 +71283,59 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroy( vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::destroy( vk::DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroy( vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::destroy( vk::DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroy( const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
@@ -55258,33 +71348,33 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::destroy( vk::SurfaceKHR surface, const vk::AllocationCallbacks* pAllocator, Dispatch const &d) const
{
d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::destroy( vk::SurfaceKHR surface, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
}
@@ -55336,7 +71426,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
}
@@ -55388,7 +71478,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, vk::PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
{
return static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
}
@@ -55453,13 +71543,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d) const
{
d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( pCallbackData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d ) const
+ VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d ) const
{
d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( &callbackData ) );
}
@@ -55467,13 +71557,13 @@
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, vk::DisplayKHR display, Dispatch const &d) const
{
return static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( vk::DisplayKHR display, Dispatch const &d ) const
{
Display dpy;
Result result = static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
@@ -55483,15 +71573,15 @@
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const vk::DeviceCreateInfo* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::Device* pDevice, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Device device;
+ vk::Device device;
Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" );
}
@@ -55499,7 +71589,7 @@
template<typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Device,Dispatch>>::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- Device device;
+ vk::Device device;
Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
@@ -55509,22 +71599,22 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR* pCreateInfo, const vk::AllocationCallbacks* pAllocator, vk::DisplayModeKHR* pMode, Dispatch const &d) const
{
return static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( vk::DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
{
- DisplayModeKHR mode;
+ vk::DisplayModeKHR mode;
Result result = static_cast<Result>( d.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 ) ) );
return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, vk::ExtensionProperties* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
}
@@ -55576,7 +71666,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, vk::LayerProperties* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
}
@@ -55628,13 +71718,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( pProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, Dispatch const &d ) const
{
std::vector<DisplayModeProperties2KHR,Allocator> properties;
uint32_t propertyCount;
@@ -55656,7 +71746,7 @@
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<DisplayModeProperties2KHR,Allocator> properties( vectorAllocator );
uint32_t propertyCount;
@@ -55680,13 +71770,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModePropertiesKHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( vk::DisplayKHR display, Dispatch const &d ) const
{
std::vector<DisplayModePropertiesKHR,Allocator> properties;
uint32_t propertyCount;
@@ -55708,7 +71798,7 @@
return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( vk::DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<DisplayModePropertiesKHR,Allocator> properties( vectorAllocator );
uint32_t propertyCount;
@@ -55732,37 +71822,37 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const vk::DisplayPlaneInfo2KHR* pDisplayPlaneInfo, vk::DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( pDisplayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( pCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilities2KHR>::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DisplayPlaneCapabilities2KHR>::type PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const &d ) const
{
- DisplayPlaneCapabilities2KHR capabilities;
+ vk::DisplayPlaneCapabilities2KHR capabilities;
Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( &displayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( &capabilities ) ) );
return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, vk::DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( vk::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d ) const
{
- DisplayPlaneCapabilitiesKHR capabilities;
+ vk::DisplayPlaneCapabilitiesKHR capabilities;
Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, vk::DisplayKHR* pDisplays, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
}
@@ -55814,7 +71904,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, vk::TimeDomainEXT* pTimeDomains, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( pTimeDomains ) ) );
}
@@ -55866,7 +71956,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t* pPropertyCount, vk::CooperativeMatrixPropertiesNV* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, pPropertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV*>( pProperties ) ) );
}
@@ -55918,7 +72008,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, vk::DisplayPlaneProperties2KHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( pProperties ) ) );
}
@@ -55970,7 +72060,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPlanePropertiesKHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
}
@@ -56022,7 +72112,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t* pPropertyCount, vk::DisplayProperties2KHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( pProperties ) ) );
}
@@ -56074,7 +72164,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, vk::DisplayPropertiesKHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
}
@@ -56126,135 +72216,135 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::ExternalBufferProperties PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
{
- ExternalBufferProperties externalBufferProperties;
+ vk::ExternalBufferProperties externalBufferProperties;
d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
return externalBufferProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const vk::PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, vk::ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d ) const
{
- ExternalBufferProperties externalBufferProperties;
+ vk::ExternalBufferProperties externalBufferProperties;
d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
return externalBufferProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::ExternalFenceProperties PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
{
- ExternalFenceProperties externalFenceProperties;
+ vk::ExternalFenceProperties externalFenceProperties;
d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
return externalFenceProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const vk::PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, vk::ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::ExternalFenceProperties PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d ) const
{
- ExternalFenceProperties externalFenceProperties;
+ vk::ExternalFenceProperties externalFenceProperties;
d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
return externalFenceProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, vk::ExternalImageFormatPropertiesNV* pExternalImageFormatProperties, Dispatch const &d) const
{
return static_cast<Result>( d.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 ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d ) const
{
- ExternalImageFormatPropertiesNV externalImageFormatProperties;
+ vk::ExternalImageFormatPropertiesNV externalImageFormatProperties;
Result result = static_cast<Result>( d.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 ) ) );
return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
{
- ExternalSemaphoreProperties externalSemaphoreProperties;
+ vk::ExternalSemaphoreProperties externalSemaphoreProperties;
d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
return externalSemaphoreProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const vk::PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d ) const
{
- ExternalSemaphoreProperties externalSemaphoreProperties;
+ vk::ExternalSemaphoreProperties externalSemaphoreProperties;
d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
return externalSemaphoreProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( vk::PhysicalDeviceFeatures* pFeatures, Dispatch const &d) const
{
d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceFeatures PhysicalDevice::getFeatures(Dispatch const &d ) const
{
- PhysicalDeviceFeatures features;
+ vk::PhysicalDeviceFeatures features;
d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
return features;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
{
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2(Dispatch const &d ) const
{
- PhysicalDeviceFeatures2 features;
+ vk::PhysicalDeviceFeatures2 features;
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return features;
}
@@ -56262,22 +72352,22 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
+ vk::PhysicalDeviceFeatures2& features = structureChain.template get<vk::PhysicalDeviceFeatures2>();
d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( vk::PhysicalDeviceFeatures2* pFeatures, Dispatch const &d) const
{
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
{
- PhysicalDeviceFeatures2 features;
+ vk::PhysicalDeviceFeatures2 features;
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return features;
}
@@ -56285,113 +72375,113 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
+ vk::PhysicalDeviceFeatures2& features = structureChain.template get<vk::PhysicalDeviceFeatures2>();
d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( vk::Format format, vk::FormatProperties* pFormatProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::FormatProperties PhysicalDevice::getFormatProperties( vk::Format format, Dispatch const &d ) const
{
- FormatProperties formatProperties;
+ vk::FormatProperties formatProperties;
d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
return formatProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::FormatProperties2 PhysicalDevice::getFormatProperties2( vk::Format format, Dispatch const &d ) const
{
- FormatProperties2 formatProperties;
+ vk::FormatProperties2 formatProperties;
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return formatProperties;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( Format format, Dispatch const &d ) const
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2( vk::Format format, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+ vk::FormatProperties2& formatProperties = structureChain.template get<vk::FormatProperties2>();
d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( vk::Format format, vk::FormatProperties2* pFormatProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::FormatProperties2 PhysicalDevice::getFormatProperties2KHR( vk::Format format, Dispatch const &d ) const
{
- FormatProperties2 formatProperties;
+ vk::FormatProperties2 formatProperties;
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return formatProperties;
}
template<typename X, typename Y, typename ...Z, typename Dispatch>
- VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( Format format, Dispatch const &d ) const
+ VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFormatProperties2KHR( vk::Format format, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
+ vk::FormatProperties2& formatProperties = structureChain.template get<vk::FormatProperties2>();
d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( vk::DeviceGeneratedCommandsFeaturesNVX* pFeatures, vk::DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d) const
{
d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features, Dispatch const &d ) const
{
- DeviceGeneratedCommandsLimitsNVX limits;
+ vk::DeviceGeneratedCommandsLimitsNVX limits;
d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
return limits;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ImageFormatProperties* pImageFormatProperties, Dispatch const &d) const
{
return static_cast<Result>( d.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 ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, Dispatch const &d ) const
{
- ImageFormatProperties imageFormatProperties;
+ vk::ImageFormatProperties imageFormatProperties;
Result result = static_cast<Result>( d.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 ) ) );
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
- ImageFormatProperties2 imageFormatProperties;
+ vk::ImageFormatProperties2 imageFormatProperties;
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
}
@@ -56399,22 +72489,22 @@
VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
+ vk::ImageFormatProperties2& imageFormatProperties = structureChain.template get<vk::ImageFormatProperties2>();
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const vk::PhysicalDeviceImageFormatInfo2* pImageFormatInfo, vk::ImageFormatProperties2* pImageFormatProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::ImageFormatProperties2>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
- ImageFormatProperties2 imageFormatProperties;
+ vk::ImageFormatProperties2 imageFormatProperties;
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
}
@@ -56422,37 +72512,37 @@
VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
+ vk::ImageFormatProperties2& imageFormatProperties = structureChain.template get<vk::ImageFormatProperties2>();
Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( vk::PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties(Dispatch const &d ) const
{
- PhysicalDeviceMemoryProperties memoryProperties;
+ vk::PhysicalDeviceMemoryProperties memoryProperties;
d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
return memoryProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
{
- PhysicalDeviceMemoryProperties2 memoryProperties;
+ vk::PhysicalDeviceMemoryProperties2 memoryProperties;
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return memoryProperties;
}
@@ -56460,22 +72550,22 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
+ vk::PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<vk::PhysicalDeviceMemoryProperties2>();
d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( vk::PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
{
- PhysicalDeviceMemoryProperties2 memoryProperties;
+ vk::PhysicalDeviceMemoryProperties2 memoryProperties;
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return memoryProperties;
}
@@ -56483,35 +72573,35 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<PhysicalDeviceMemoryProperties2>();
+ vk::PhysicalDeviceMemoryProperties2& memoryProperties = structureChain.template get<vk::PhysicalDeviceMemoryProperties2>();
d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, vk::MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( vk::SampleCountFlagBits samples, Dispatch const &d ) const
{
- MultisamplePropertiesEXT multisampleProperties;
+ vk::MultisamplePropertiesEXT multisampleProperties;
d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) );
return multisampleProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHR( vk::SurfaceKHR surface, uint32_t* pRectCount, vk::Rect2D* pRects, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
{
std::vector<Rect2D,Allocator> rects;
uint32_t rectCount;
@@ -56533,7 +72623,7 @@
return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<Rect2D,Allocator> rects( vectorAllocator );
uint32_t rectCount;
@@ -56557,30 +72647,30 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getProperties( vk::PhysicalDeviceProperties* pProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceProperties PhysicalDevice::getProperties(Dispatch const &d ) const
{
- PhysicalDeviceProperties properties;
+ vk::PhysicalDeviceProperties properties;
d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
return properties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceProperties2 PhysicalDevice::getProperties2(Dispatch const &d ) const
{
- PhysicalDeviceProperties2 properties;
+ vk::PhysicalDeviceProperties2 properties;
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return properties;
}
@@ -56588,22 +72678,22 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
+ vk::PhysicalDeviceProperties2& properties = structureChain.template get<vk::PhysicalDeviceProperties2>();
d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( vk::PhysicalDeviceProperties2* pProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
+ VULKAN_HPP_INLINE vk::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
{
- PhysicalDeviceProperties2 properties;
+ vk::PhysicalDeviceProperties2 properties;
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return properties;
}
@@ -56611,14 +72701,14 @@
VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR(Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
+ vk::PhysicalDeviceProperties2& properties = structureChain.template get<vk::PhysicalDeviceProperties2>();
d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
return structureChain;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
}
@@ -56646,7 +72736,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
}
@@ -56694,7 +72784,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
}
@@ -56742,13 +72832,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, uint32_t* pPropertyCount, vk::SparseImageFormatProperties* pProperties, Dispatch const &d) const
{
d.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 ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d ) const
+ VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Dispatch const &d ) const
{
std::vector<SparseImageFormatProperties,Allocator> properties;
uint32_t propertyCount;
@@ -56758,7 +72848,7 @@
return properties;
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<SparseImageFormatProperties,Allocator> properties( vectorAllocator );
uint32_t propertyCount;
@@ -56770,7 +72860,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
}
@@ -56798,7 +72888,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d) const
+ VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const vk::PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, vk::SparseImageFormatProperties2* pProperties, Dispatch const &d) const
{
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
}
@@ -56826,7 +72916,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t* pCombinationCount, vk::FramebufferMixedSamplesCombinationNV* pCombinations, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, pCombinationCount, reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>( pCombinations ) ) );
}
@@ -56878,30 +72968,30 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, vk::SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( vk::SurfaceKHR surface, Dispatch const &d ) const
{
- SurfaceCapabilities2EXT surfaceCapabilities;
+ vk::SurfaceCapabilities2EXT surfaceCapabilities;
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, vk::SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
{
- SurfaceCapabilities2KHR surfaceCapabilities;
+ vk::SurfaceCapabilities2KHR surfaceCapabilities;
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
}
@@ -56909,29 +72999,29 @@
VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d ) const
{
StructureChain<X, Y, Z...> structureChain;
- SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
+ vk::SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<vk::SurfaceCapabilities2KHR>();
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, vk::SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
{
- SurfaceCapabilitiesKHR surfaceCapabilities;
+ vk::SurfaceCapabilitiesKHR surfaceCapabilities;
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, vk::SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) );
}
@@ -56983,13 +73073,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( vk::SurfaceKHR surface, uint32_t* pSurfaceFormatCount, vk::SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
{
std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
uint32_t surfaceFormatCount;
@@ -57011,7 +73101,7 @@
return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<SurfaceFormatKHR,Allocator> surfaceFormats( vectorAllocator );
uint32_t surfaceFormatCount;
@@ -57036,7 +73126,7 @@
#ifdef VK_USE_PLATFORM_WIN32_KHR
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const vk::PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
}
@@ -57089,13 +73179,13 @@
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( vk::SurfaceKHR surface, uint32_t* pPresentModeCount, vk::PresentModeKHR* pPresentModes, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( vk::SurfaceKHR surface, Dispatch const &d ) const
{
std::vector<PresentModeKHR,Allocator> presentModes;
uint32_t presentModeCount;
@@ -57117,7 +73207,7 @@
return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
}
template<typename Allocator, typename Dispatch>
- VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( vk::SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const
{
std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator );
uint32_t presentModeCount;
@@ -57141,15 +73231,15 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, vk::Bool32* pSupported, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32*>( pSupported ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, vk::SurfaceKHR surface, Dispatch const &d ) const
{
- Bool32 supported;
+ vk::Bool32 supported;
Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32*>( &supported ) ) );
return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" );
}
@@ -57218,15 +73308,15 @@
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, vk::DisplayKHR* pDisplay, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<vk::DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
{
- DisplayKHR display;
+ vk::DisplayKHR display;
Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" );
}
@@ -57235,13 +73325,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d) const
{
return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( vk::DisplayKHR display, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" );
@@ -57249,7 +73339,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, vk::CheckpointDataNV* pCheckpointData, Dispatch const &d) const
{
d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( pCheckpointData ) );
}
@@ -57277,7 +73367,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
{
d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
}
@@ -57290,13 +73380,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const vk::BindSparseInfo* pBindInfo, vk::Fence fence, Dispatch const &d) const
{
return static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const vk::BindSparseInfo> bindInfo, vk::Fence fence, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" );
@@ -57318,7 +73408,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const vk::DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
{
d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
}
@@ -57331,7 +73421,7 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Queue::presentKHR( const vk::PresentInfoKHR* pPresentInfo, Dispatch const &d) const
{
return static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
}
@@ -57346,13 +73436,13 @@
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d) const
{
return static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
}
#else
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Queue::setPerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::setPerformanceConfigurationINTEL" );
@@ -57360,13 +73450,13 @@
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
- VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const
+ VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const vk::SubmitInfo* pSubmits, vk::Fence fence, Dispatch const &d) const
{
return static_cast<Result>( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
- VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d ) const
+ VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const vk::SubmitInfo> submits, vk::Fence fence, Dispatch const &d ) const
{
Result result = static_cast<Result>( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" );
@@ -57449,6 +73539,7 @@
template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageFormatProperties2, FilterCubicImageViewImageFormatPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<FramebufferCreateInfo, FramebufferAttachmentsCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierExplicitCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageDrmFormatModifierListCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
@@ -57486,6 +73577,8 @@
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceBufferDeviceAddressFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceBufferDeviceAddressFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceCoherentMemoryFeaturesAMD>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceCoherentMemoryFeaturesAMD>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceComputeShaderDerivativesFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceConditionalRenderingFeaturesEXT>{ enum { value = true }; };
@@ -57513,8 +73606,6 @@
template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceExternalImageFormatInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFeatures2>{ enum { value = true }; };
- template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFloat16Int8FeaturesKHR>{ enum { value = true }; };
- template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFloat16Int8FeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceFloatControlsPropertiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFragmentDensityMapFeaturesEXT>{ enum { value = true }; };
@@ -57528,9 +73619,16 @@
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceIDProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageDrmFormatModifierInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2, PhysicalDeviceImageViewImageFormatInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceImagelessFramebufferFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceImagelessFramebufferFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceIndexTypeUint8FeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceIndexTypeUint8FeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceInlineUniformBlockFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceInlineUniformBlockPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceLineRasterizationFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceLineRasterizationFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceLineRasterizationPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMaintenance3Properties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceMemoryProperties2, PhysicalDeviceMemoryBudgetPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceMemoryPriorityFeaturesEXT>{ enum { value = true }; };
@@ -57543,6 +73641,8 @@
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePCIBusInfoPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePointClippingProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceProtectedMemoryFeatures>{ enum { value = true }; };
@@ -57559,20 +73659,40 @@
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceScalarBlockLayoutFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderAtomicInt64FeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderClockFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderClockFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCoreProperties2AMD>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderCorePropertiesAMD>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderDrawParametersFeatures>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderDrawParametersFeatures>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderFloat16Int8FeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderFloat16Int8FeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderImageFootprintFeaturesNV>{ enum { value = true }; };
- template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderIntegerFunctions2INTEL>{ enum { value = true }; };
- template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderIntegerFunctions2INTEL>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderSMBuiltinsFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderSMBuiltinsFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShaderSMBuiltinsPropertiesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceShadingRateImageFeaturesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceShadingRateImagePropertiesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSubgroupProperties>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceSubgroupSizeControlFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceSubgroupSizeControlFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSubgroupSizeControlPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTexelBufferAlignmentFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTexelBufferAlignmentFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTexelBufferAlignmentPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTimelineSemaphoreFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTimelineSemaphoreFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTimelineSemaphorePropertiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceTransformFeedbackFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceTransformFeedbackPropertiesEXT>{ enum { value = true }; };
@@ -57588,6 +73708,8 @@
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceYcbcrImageArraysFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceYcbcrImageArraysFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineCompilerControlCreateInfoAMD>{ enum { value = true }; };
+ template <> struct isStructureChainValid<ComputePipelineCreateInfo, PipelineCompilerControlCreateInfoAMD>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageReductionStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; };
@@ -57597,10 +73719,12 @@
template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationDepthClipStateCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationLineStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateStreamCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineRepresentativeFragmentTestStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineSampleLocationsStateCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineShaderStageCreateInfo, PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineTessellationStateCreateInfo, PipelineTessellationDomainOriginStateCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineVertexInputStateCreateInfo, PipelineVertexInputDivisorStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportCoarseSampleOrderStateCreateInfoNV>{ enum { value = true }; };
@@ -57615,7 +73739,9 @@
template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<QueueFamilyProperties2, QueueFamilyCheckpointPropertiesNV>{ enum { value = true }; };
+ template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassAttachmentBeginInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<RenderPassCreateInfo2KHR, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassMultiviewCreateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassSampleLocationsBeginInfoEXT>{ enum { value = true }; };
@@ -57624,6 +73750,8 @@
template <> struct isStructureChainValid<ImageFormatProperties2, SamplerYcbcrConversionImageFormatProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<SamplerCreateInfo, SamplerYcbcrConversionInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageViewCreateInfo, SamplerYcbcrConversionInfo>{ enum { value = true }; };
+ template <> struct isStructureChainValid<SemaphoreCreateInfo, SemaphoreTypeCreateInfoKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceExternalSemaphoreInfo, SemaphoreTypeCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<SubpassDescription2KHR, SubpassDescriptionDepthStencilResolveKHR>{ enum { value = true }; };
@@ -57642,6 +73770,8 @@
template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainCounterCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainDisplayNativeHdrCreateInfoAMD>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageFormatProperties2, TextureLODGatherFormatPropertiesAMD>{ enum { value = true }; };
+ template <> struct isStructureChainValid<SubmitInfo, TimelineSemaphoreSubmitInfoKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<BindSparseInfo, TimelineSemaphoreSubmitInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFeaturesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; };
#ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -57653,6 +73783,70 @@
template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetAccelerationStructureNV>{ enum { value = true }; };
template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ enum { value = true }; };
+#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL)
+# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
+#endif
+
+#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
+ class DynamicLoader
+ {
+ public:
+ DynamicLoader() : m_success( false )
+ {
+#if defined(__linux__)
+ m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
+#elif defined(_WIN32)
+ m_library = LoadLibrary( "vulkan-1.dll" );
+#else
+ assert( false && "unsupported platform" );
+#endif
+
+ m_success = m_library != 0;
+#ifndef VULKAN_HPP_NO_EXCEPTIONS
+ if ( !m_success )
+ {
+ // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
+ throw std::runtime_error( "Failed to load vulkan library!" );
+ }
+#endif
+ }
+
+ ~DynamicLoader()
+ {
+ if ( m_library )
+ {
+#if defined(__linux__)
+ dlclose( m_library );
+#elif defined(_WIN32)
+ FreeLibrary( m_library );
+#endif
+ }
+ }
+
+ template <typename T>
+ T getProcAddress( const char* function ) const
+ {
+#if defined(__linux__)
+ return (T)dlsym( m_library, function );
+#elif defined(_WIN32)
+ return (T)GetProcAddress( m_library, function );
+#endif
+ }
+
+ bool success() const { return m_success; }
+
+ private:
+ bool m_success;
+#if defined(__linux__)
+ void *m_library;
+#elif defined(_WIN32)
+ HMODULE m_library;
+#else
+#error unsupported platform
+#endif
+ };
+#endif
+
class DispatchLoaderDynamic
{
public:
@@ -57735,6 +73929,7 @@
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetEvent vkCmdSetEvent = 0;
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
+ PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0;
PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0;
@@ -57895,10 +74090,14 @@
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0;
PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
+ PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
+ PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0;
+ PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
+ PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
#ifdef VK_USE_PLATFORM_WIN32_KHR
PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
@@ -57938,6 +74137,7 @@
PFN_vkSetEvent vkSetEvent = 0;
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;
+ PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;
PFN_vkTrimCommandPool vkTrimCommandPool = 0;
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0;
@@ -57947,6 +74147,7 @@
PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
PFN_vkWaitForFences vkWaitForFences = 0;
+ PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
#ifdef VK_USE_PLATFORM_ANDROID_KHR
PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -58085,18 +74286,34 @@
#if !defined(VK_NO_PROTOTYPES)
// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
- DispatchLoaderDynamic(vk::Instance const& instance, vk::Device const& device = {})
+ DispatchLoaderDynamic(vk::Instance const& instance, vk::Device const& device)
{
init(instance, device);
}
// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
- void init(vk::Instance const& instance, vk::Device const& device = {})
+ void init(vk::Instance const& instance, vk::Device const& device)
{
- init(instance, ::vkGetInstanceProcAddr, device, device ? ::vkGetDeviceProcAddr : nullptr);
+ init(static_cast<VkInstance>(instance), ::vkGetInstanceProcAddr, static_cast<VkDevice>(device), device ? ::vkGetDeviceProcAddr : nullptr);
}
#endif // !defined(VK_NO_PROTOTYPES)
+ DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr)
+ {
+ init(getInstanceProcAddr);
+ }
+
+ void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr )
+ {
+ VULKAN_HPP_ASSERT(getInstanceProcAddr);
+
+ vkGetInstanceProcAddr = getInstanceProcAddr;
+ vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) );
+ vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) );
+ vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) );
+ vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) );
+ }
+
// This interface does not require a linked vulkan library.
DispatchLoaderDynamic( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr )
{
@@ -58104,302 +74321,18 @@
}
// This interface does not require a linked vulkan library.
- void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr )
+ void init( VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device = VK_NULL_HANDLE, PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr )
{
- assert(instance && getInstanceProcAddr);
- assert(!!device == !!getDeviceProcAddr);
+ VULKAN_HPP_ASSERT(instance && getInstanceProcAddr);
vkGetInstanceProcAddr = getInstanceProcAddr;
- vkGetDeviceProcAddr = getDeviceProcAddr ? getDeviceProcAddr : PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr") );
- vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( instance, "vkCreateInstance" ) );
- vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateInstanceExtensionProperties" ) );
- vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateInstanceLayerProperties" ) );
- vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( instance, "vkEnumerateInstanceVersion" ) );
- vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
- vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
- vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
- vkCmdBeginQuery = PFN_vkCmdBeginQuery( device ? vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
- vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
- vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( device ? vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
- vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( device ? vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
- vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
- vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
- vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
- vkCmdBindPipeline = PFN_vkCmdBindPipeline( device ? vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) : vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
- vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( device ? vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) : vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) );
- vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( device ? vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
- vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( device ? vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) : vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
- vkCmdBlitImage = PFN_vkCmdBlitImage( device ? vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) : vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
- vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) );
- vkCmdClearAttachments = PFN_vkCmdClearAttachments( device ? vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) : vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
- vkCmdClearColorImage = PFN_vkCmdClearColorImage( device ? vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) : vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
- vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( device ? vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) : vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
- vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) );
- vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
- vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( device ? vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
- vkCmdCopyImage = PFN_vkCmdCopyImage( device ? vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
- vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
- vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
- vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) );
- vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
- vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
- vkCmdDispatch = PFN_vkCmdDispatch( device ? vkGetDeviceProcAddr( device, "vkCmdDispatch" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
- vkCmdDispatchBase = PFN_vkCmdDispatchBase( device ? vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
- vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( device ? vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
- vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( device ? vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) : vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
- vkCmdDraw = PFN_vkCmdDraw( device ? vkGetDeviceProcAddr( device, "vkCmdDraw" ) : vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
- vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
- vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
- vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
- vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
- vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
- vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
- vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
- vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( device ? vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
- vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( device ? vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
- vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( device ? vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) );
- vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( device ? vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) : vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) );
- vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) );
- vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
- vkCmdEndQuery = PFN_vkCmdEndQuery( device ? vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) : vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
- vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
- vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( device ? vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) : vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
- vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( device ? vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
- vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( device ? vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
- vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( device ? vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) : vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
- vkCmdFillBuffer = PFN_vkCmdFillBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
- vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
- vkCmdNextSubpass = PFN_vkCmdNextSubpass( device ? vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) : vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
- vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( device ? vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
- vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( device ? vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) : vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
- vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX( device ? vkGetDeviceProcAddr( device, "vkCmdProcessCommandsNVX" ) : vkGetInstanceProcAddr( instance, "vkCmdProcessCommandsNVX" ) );
- vkCmdPushConstants = PFN_vkCmdPushConstants( device ? vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) : vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
- vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( device ? vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) );
- vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
- vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX( device ? vkGetDeviceProcAddr( device, "vkCmdReserveSpaceForCommandsNVX" ) : vkGetInstanceProcAddr( instance, "vkCmdReserveSpaceForCommandsNVX" ) );
- vkCmdResetEvent = PFN_vkCmdResetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
- vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( device ? vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) : vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
- vkCmdResolveImage = PFN_vkCmdResolveImage( device ? vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) : vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
- vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( device ? vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) : vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
- vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
- vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
- vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( device ? vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
- vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( device ? vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
- vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
- vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( device ? vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
- vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
- vkCmdSetEvent = PFN_vkCmdSetEvent( device ? vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) : vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
- vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
- vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( device ? vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) : vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
- vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
- vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
- vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( device ? vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) : vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
- vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( device ? vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) : vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
- vkCmdSetScissor = PFN_vkCmdSetScissor( device ? vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) : vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
- vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
- vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
- vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( device ? vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) : vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
- vkCmdSetViewport = PFN_vkCmdSetViewport( device ? vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) : vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
- vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
- vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( device ? vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) : vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
- vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( device ? vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) : vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
- vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( device ? vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) : vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
- vkCmdWaitEvents = PFN_vkCmdWaitEvents( device ? vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) : vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
- vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( device ? vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
- vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( device ? vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
- vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( device ? vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) : vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
- vkEndCommandBuffer = PFN_vkEndCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
- vkResetCommandBuffer = PFN_vkResetCommandBuffer( device ? vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) : vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( device ? vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) : vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
- vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( device ? vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) : vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
- vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( device ? vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) : vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
- vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( device ? vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) : vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
- vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
- vkAllocateMemory = PFN_vkAllocateMemory( device ? vkGetDeviceProcAddr( device, "vkAllocateMemory" ) : vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
- vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( device ? vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) : vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
- vkBindBufferMemory = PFN_vkBindBufferMemory( device ? vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) : vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
- vkBindBufferMemory2 = PFN_vkBindBufferMemory2( device ? vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) : vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
- vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( device ? vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) : vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
- vkBindImageMemory = PFN_vkBindImageMemory( device ? vkGetDeviceProcAddr( device, "vkBindImageMemory" ) : vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
- vkBindImageMemory2 = PFN_vkBindImageMemory2( device ? vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) : vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
- vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( device ? vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) : vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
- vkCompileDeferredNV = PFN_vkCompileDeferredNV( device ? vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) : vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
- vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) );
- vkCreateBuffer = PFN_vkCreateBuffer( device ? vkGetDeviceProcAddr( device, "vkCreateBuffer" ) : vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
- vkCreateBufferView = PFN_vkCreateBufferView( device ? vkGetDeviceProcAddr( device, "vkCreateBufferView" ) : vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
- vkCreateCommandPool = PFN_vkCreateCommandPool( device ? vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) : vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
- vkCreateComputePipelines = PFN_vkCreateComputePipelines( device ? vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) : vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
- vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
- vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
- vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
- vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
- vkCreateEvent = PFN_vkCreateEvent( device ? vkGetDeviceProcAddr( device, "vkCreateEvent" ) : vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
- vkCreateFence = PFN_vkCreateFence( device ? vkGetDeviceProcAddr( device, "vkCreateFence" ) : vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
- vkCreateFramebuffer = PFN_vkCreateFramebuffer( device ? vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) : vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
- vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( device ? vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) : vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
- vkCreateImage = PFN_vkCreateImage( device ? vkGetDeviceProcAddr( device, "vkCreateImage" ) : vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
- vkCreateImageView = PFN_vkCreateImageView( device ? vkGetDeviceProcAddr( device, "vkCreateImageView" ) : vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
- vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX( device ? vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNVX" ) : vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNVX" ) );
- vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX( device ? vkGetDeviceProcAddr( device, "vkCreateObjectTableNVX" ) : vkGetInstanceProcAddr( instance, "vkCreateObjectTableNVX" ) );
- vkCreatePipelineCache = PFN_vkCreatePipelineCache( device ? vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) : vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
- vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( device ? vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) : vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
- vkCreateQueryPool = PFN_vkCreateQueryPool( device ? vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) : vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
- vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( device ? vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) : vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
- vkCreateRenderPass = PFN_vkCreateRenderPass( device ? vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) : vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
- vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( device ? vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) : vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
- vkCreateSampler = PFN_vkCreateSampler( device ? vkGetDeviceProcAddr( device, "vkCreateSampler" ) : vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
- vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( device ? vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) : vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
- vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( device ? vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
- vkCreateSemaphore = PFN_vkCreateSemaphore( device ? vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) : vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
- vkCreateShaderModule = PFN_vkCreateShaderModule( device ? vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) : vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
- vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( device ? vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
- vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( device ? vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) : vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
- vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( device ? vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) : vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) );
- vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( device ? vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) : vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) );
- vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( device ? vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) : vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) );
- vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( device ? vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) : vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
- vkDestroyBuffer = PFN_vkDestroyBuffer( device ? vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) : vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
- vkDestroyBufferView = PFN_vkDestroyBufferView( device ? vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) : vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
- vkDestroyCommandPool = PFN_vkDestroyCommandPool( device ? vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) : vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
- vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
- vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
- vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
- vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
- vkDestroyDevice = PFN_vkDestroyDevice( device ? vkGetDeviceProcAddr( device, "vkDestroyDevice" ) : vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
- vkDestroyEvent = PFN_vkDestroyEvent( device ? vkGetDeviceProcAddr( device, "vkDestroyEvent" ) : vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
- vkDestroyFence = PFN_vkDestroyFence( device ? vkGetDeviceProcAddr( device, "vkDestroyFence" ) : vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
- vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( device ? vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) : vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
- vkDestroyImage = PFN_vkDestroyImage( device ? vkGetDeviceProcAddr( device, "vkDestroyImage" ) : vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
- vkDestroyImageView = PFN_vkDestroyImageView( device ? vkGetDeviceProcAddr( device, "vkDestroyImageView" ) : vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
- vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX( device ? vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNVX" ) : vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNVX" ) );
- vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX( device ? vkGetDeviceProcAddr( device, "vkDestroyObjectTableNVX" ) : vkGetInstanceProcAddr( instance, "vkDestroyObjectTableNVX" ) );
- vkDestroyPipeline = PFN_vkDestroyPipeline( device ? vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) : vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
- vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( device ? vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) : vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
- vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( device ? vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) : vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
- vkDestroyQueryPool = PFN_vkDestroyQueryPool( device ? vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) : vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
- vkDestroyRenderPass = PFN_vkDestroyRenderPass( device ? vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) : vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
- vkDestroySampler = PFN_vkDestroySampler( device ? vkGetDeviceProcAddr( device, "vkDestroySampler" ) : vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
- vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( device ? vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) : vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
- vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( device ? vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) : vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
- vkDestroySemaphore = PFN_vkDestroySemaphore( device ? vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) : vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
- vkDestroyShaderModule = PFN_vkDestroyShaderModule( device ? vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) : vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
- vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( device ? vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) : vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
- vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( device ? vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) : vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) );
- vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( device ? vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) : vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
- vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( device ? vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) : vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
- vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( device ? vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) : vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
- vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( device ? vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) : vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
- vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
- vkFreeMemory = PFN_vkFreeMemory( device ? vkGetDeviceProcAddr( device, "vkFreeMemory" ) : vkGetInstanceProcAddr( instance, "vkFreeMemory" ) );
- vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( device ? vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) : vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) );
- vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( device ? vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) : vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
- vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( device ? vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) : vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( device ? vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) : vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
- vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( device ? vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) : vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
- vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( device ? vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) : vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
- vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( device ? vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) : vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
- vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( device ? vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) : vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
- vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( device ? vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) : vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
- vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( device ? vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
- vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
- vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
- vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( device ? vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
- vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( device ? vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
- vkGetDeviceQueue = PFN_vkGetDeviceQueue( device ? vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
- vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( device ? vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) : vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
- vkGetEventStatus = PFN_vkGetEventStatus( device ? vkGetDeviceProcAddr( device, "vkGetEventStatus" ) : vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
- vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( device ? vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) : vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
- vkGetFenceStatus = PFN_vkGetFenceStatus( device ? vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) : vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( device ? vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) : vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
- vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( device ? vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) : vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
- vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( device ? vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) : vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
- vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( device ? vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) : vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
- vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( device ? vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) : vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
- vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( device ? vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) : vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
- vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( device ? vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) : vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
- vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( device ? vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) : vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
- vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( device ? vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) : vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
- vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( device ? vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
- vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
- vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( device ? vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( device ? vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
- vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( device ? vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) : vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
- vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( device ? vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) : vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
- vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( device ? vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) : vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
- vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( device ? vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) : vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
- vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( device ? vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) : vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
- vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( device ? vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) : vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
- vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( device ? vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( device ? vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) : vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) );
- vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( device ? vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) : vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
- vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( device ? vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
- vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( device ? vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) : vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
- vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( device ? vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) : vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) );
- vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( device ? vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) : vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( device ? vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) : vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( device ? vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) : vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( device ? vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) : vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) );
- vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( device ? vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) : vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
- vkMapMemory = PFN_vkMapMemory( device ? vkGetDeviceProcAddr( device, "vkMapMemory" ) : vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
- vkMergePipelineCaches = PFN_vkMergePipelineCaches( device ? vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) : vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
- vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( device ? vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) : vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
- vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
- vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( device ? vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) : vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
- vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkRegisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkRegisterObjectsNVX" ) );
-#ifdef VK_USE_PLATFORM_WIN32_KHR
- vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( device ? vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) : vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
- vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( device ? vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) : vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
- vkResetCommandPool = PFN_vkResetCommandPool( device ? vkGetDeviceProcAddr( device, "vkResetCommandPool" ) : vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
- vkResetDescriptorPool = PFN_vkResetDescriptorPool( device ? vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) : vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
- vkResetEvent = PFN_vkResetEvent( device ? vkGetDeviceProcAddr( device, "vkResetEvent" ) : vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
- vkResetFences = PFN_vkResetFences( device ? vkGetDeviceProcAddr( device, "vkResetFences" ) : vkGetInstanceProcAddr( instance, "vkResetFences" ) );
- vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( device ? vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) : vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
- vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
- vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( device ? vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) : vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
- vkSetEvent = PFN_vkSetEvent( device ? vkGetDeviceProcAddr( device, "vkSetEvent" ) : vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
- vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( device ? vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) : vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
- vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( device ? vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) : vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
- vkTrimCommandPool = PFN_vkTrimCommandPool( device ? vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) : vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
- vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( device ? vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) : vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
- vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( device ? vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) : vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
- vkUnmapMemory = PFN_vkUnmapMemory( device ? vkGetDeviceProcAddr( device, "vkUnmapMemory" ) : vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
- vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX( device ? vkGetDeviceProcAddr( device, "vkUnregisterObjectsNVX" ) : vkGetInstanceProcAddr( instance, "vkUnregisterObjectsNVX" ) );
- vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
- vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
- vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( device ? vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) : vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
- vkWaitForFences = PFN_vkWaitForFences( device ? vkGetDeviceProcAddr( device, "vkWaitForFences" ) : vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
+ init( vk::Instance(instance) );
+ if (device) {
+ init( vk::Device(device) );
+ }
+ }
+
+ void init( vk::Instance instance )
+ {
#ifdef VK_USE_PLATFORM_ANDROID_KHR
vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@@ -58522,16 +74455,618 @@
vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
- vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( device ? vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) : vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
- vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
- vkQueueBindSparse = PFN_vkQueueBindSparse( device ? vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) : vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
- vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
- vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( device ? vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) : vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
- vkQueuePresentKHR = PFN_vkQueuePresentKHR( device ? vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) : vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
- vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( device ? vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) : vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
- vkQueueSubmit = PFN_vkQueueSubmit( device ? vkGetDeviceProcAddr( device, "vkQueueSubmit" ) : vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
- vkQueueWaitIdle = PFN_vkQueueWaitIdle( device ? vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) : vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
+ vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
+ vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
+ vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
+ vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
+ vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
+ vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
+ vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
+ vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
+ vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
+ vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
+ vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
+ vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) );
+ vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
+ vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
+ vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
+ vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) );
+ vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
+ vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
+ vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
+ vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) );
+ vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
+ vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
+ vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
+ vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
+ vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
+ vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) );
+ vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
+ vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
+ vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
+ vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
+ vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
+ vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
+ vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
+ vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
+ vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
+ vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
+ vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
+ vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
+ vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
+ vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
+ vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
+ vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
+ vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) );
+ vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) );
+ vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) );
+ vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
+ vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
+ vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
+ vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
+ vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
+ vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
+ vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
+ vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
+ vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
+ vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
+ vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
+ vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
+ vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX( vkGetInstanceProcAddr( instance, "vkCmdProcessCommandsNVX" ) );
+ vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
+ vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) );
+ vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
+ vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX( vkGetInstanceProcAddr( instance, "vkCmdReserveSpaceForCommandsNVX" ) );
+ vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
+ vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
+ vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
+ vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
+ vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
+ vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
+ vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
+ vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
+ vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
+ vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
+ vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
+ vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
+ vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
+ vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
+ vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
+ vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
+ vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
+ vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
+ vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
+ vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
+ vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
+ vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
+ vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
+ vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
+ vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
+ vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
+ vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
+ vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
+ vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
+ vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
+ vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
+ vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
+ vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
+ vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
+ vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
+ vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
+ vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
+ vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
+ vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
+ vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
+ vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
+ vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
+ vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
+ vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
+ vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
+ vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
+ vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
+ vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) );
+ vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
+ vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
+ vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
+ vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
+ vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
+ vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
+ vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
+ vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
+ vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
+ vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
+ vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
+ vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
+ vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
+ vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
+ vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNVX" ) );
+ vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX( vkGetInstanceProcAddr( instance, "vkCreateObjectTableNVX" ) );
+ vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
+ vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
+ vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
+ vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
+ vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
+ vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
+ vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
+ vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
+ vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
+ vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
+ vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
+ vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
+ vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
+ vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) );
+ vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) );
+ vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) );
+ vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
+ vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
+ vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
+ vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
+ vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
+ vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
+ vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
+ vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
+ vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
+ vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
+ vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
+ vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
+ vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
+ vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
+ vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNVX" ) );
+ vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX( vkGetInstanceProcAddr( instance, "vkDestroyObjectTableNVX" ) );
+ vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
+ vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
+ vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
+ vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
+ vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
+ vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
+ vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
+ vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
+ vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
+ vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
+ vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
+ vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) );
+ vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
+ vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
+ vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
+ vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
+ vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
+ vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) );
+ vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) );
+ vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+ vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
+ vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
+ vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
+ vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
+ vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
+ vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
+ vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
+ vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
+ vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
+ vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
+ vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
+ vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
+ vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
+ vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
+ vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
+ vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
+ vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
+ vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
+ vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
+ vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
+ vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
+ vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
+ vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
+ vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
+ vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+ vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
+ vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
+ vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
+ vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
+ vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
+ vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
+ vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) );
+ vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
+ vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
+ vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
+ vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
+ vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
+ vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) );
+ vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) );
+ vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
+ vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
+ vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
+ vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) );
+ vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) );
+ vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
+ vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
+ vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
+ vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
+ vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
+ vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
+ vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX( vkGetInstanceProcAddr( instance, "vkRegisterObjectsNVX" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
+ vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
+ vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
+ vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
+ vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
+ vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
+ vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
+ vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
+ vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
+ vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
+ vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
+ vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
+ vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
+ vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
+ vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
+ vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
+ vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX( vkGetInstanceProcAddr( instance, "vkUnregisterObjectsNVX" ) );
+ vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
+ vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
+ vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
+ vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
+ vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
+ vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
+ vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
+ vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
+ vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
+ vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
+ vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
+ vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
+ vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
+ vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
+ }
+
+ void init( vk::Device device )
+ {
+ vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
+ vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
+ vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
+ vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
+ vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
+ vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
+ vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
+ vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
+ vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
+ vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
+ vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
+ vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
+ vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
+ vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
+ vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
+ vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
+ vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
+ vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
+ vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
+ vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
+ vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
+ vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
+ vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
+ vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
+ vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
+ vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
+ vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
+ vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
+ vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
+ vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
+ vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
+ vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
+ vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
+ vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
+ vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
+ vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
+ vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
+ vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
+ vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
+ vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
+ vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
+ vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
+ vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
+ vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
+ vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
+ vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
+ vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
+ vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
+ vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
+ vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
+ vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
+ vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
+ vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
+ vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
+ vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
+ vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
+ vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
+ vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX( vkGetDeviceProcAddr( device, "vkCmdProcessCommandsNVX" ) );
+ vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
+ vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
+ vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
+ vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX( vkGetDeviceProcAddr( device, "vkCmdReserveSpaceForCommandsNVX" ) );
+ vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
+ vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
+ vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
+ vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
+ vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
+ vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
+ vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
+ vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
+ vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
+ vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
+ vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
+ vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
+ vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
+ vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
+ vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
+ vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
+ vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
+ vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
+ vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
+ vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
+ vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
+ vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
+ vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
+ vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
+ vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
+ vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
+ vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
+ vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
+ vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
+ vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
+ vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
+ vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
+ vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
+ vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
+ vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
+ vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
+ vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
+ vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
+ vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
+ vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
+ vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
+ vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
+ vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
+ vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
+ vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
+ vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
+ vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
+ vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
+ vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
+ vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
+ vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
+ vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
+ vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
+ vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
+ vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
+ vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
+ vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
+ vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
+ vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
+ vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
+ vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
+ vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
+ vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNVX" ) );
+ vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX( vkGetDeviceProcAddr( device, "vkCreateObjectTableNVX" ) );
+ vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
+ vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
+ vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
+ vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
+ vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
+ vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
+ vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
+ vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
+ vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
+ vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
+ vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
+ vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
+ vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
+ vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
+ vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
+ vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
+ vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
+ vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
+ vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
+ vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
+ vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
+ vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
+ vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
+ vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
+ vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
+ vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
+ vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
+ vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
+ vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
+ vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
+ vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNVX" ) );
+ vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX( vkGetDeviceProcAddr( device, "vkDestroyObjectTableNVX" ) );
+ vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
+ vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
+ vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
+ vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
+ vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
+ vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
+ vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
+ vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
+ vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
+ vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
+ vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
+ vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
+ vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
+ vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
+ vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
+ vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
+ vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
+ vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
+ vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
+ vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+ vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
+ vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
+ vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
+ vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
+ vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
+ vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
+ vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
+ vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
+ vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
+ vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
+ vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
+ vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
+ vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
+ vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
+ vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
+ vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
+ vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
+ vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
+ vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
+ vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
+ vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
+ vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
+ vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
+ vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
+ vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+ vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
+ vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
+ vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
+ vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
+ vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
+ vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
+ vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
+ vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
+ vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
+ vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
+ vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
+ vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
+ vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
+ vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
+ vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
+ vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
+ vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
+ vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
+ vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
+ vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
+ vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
+ vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
+ vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
+ vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
+ vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
+ vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX( vkGetDeviceProcAddr( device, "vkRegisterObjectsNVX" ) );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+ vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
+ vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
+ vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
+ vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
+ vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
+ vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
+ vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
+ vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
+ vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
+ vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
+ vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
+ vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
+ vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
+ vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
+ vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
+ vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
+ vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX( vkGetDeviceProcAddr( device, "vkUnregisterObjectsNVX" ) );
+ vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
+ vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
+ vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
+ vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
+ vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
+ vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
+ vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
+ vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
+ vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
+ vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
+ vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
+ vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
+ vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
+ vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
}
};
+
} // namespace VULKAN_HPP_NAMESPACE
#endif
diff --git a/include/vulkan/vulkan_android.h b/include/vulkan/vulkan_android.h
index a194f16..ef55c96 100644
--- a/include/vulkan/vulkan_android.h
+++ b/include/vulkan/vulkan_android.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_ANDROID_H_
#define VULKAN_ANDROID_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_KHR_android_surface 1
struct ANativeWindow;
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 36dc10d..5ae9fdc 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_CORE_H_
#define VULKAN_CORE_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_VERSION_1_0 1
#include "vk_platform.h"
@@ -43,7 +44,7 @@
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
// Version of this file
-#define VK_HEADER_VERSION 111
+#define VK_HEADER_VERSION 125
#define VK_NULL_HANDLE 0
@@ -307,6 +308,7 @@
VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
@@ -327,7 +329,7 @@
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = 1000082000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = 1000082000,
VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
@@ -351,6 +353,10 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = 1000108000,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = 1000108001,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = 1000108002,
+ VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = 1000108003,
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
@@ -437,11 +443,14 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = 1000175000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
+ VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
@@ -463,7 +472,13 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL = 1000209000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = 1000207000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = 1000207001,
+ VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = 1000207002,
+ VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = 1000207003,
+ VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = 1000207004,
+ VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = 1000207005,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = 1000210000,
VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
@@ -480,6 +495,11 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
@@ -503,7 +523,20 @@
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
+ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
+ VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
+ VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -539,6 +572,7 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
@@ -823,6 +857,20 @@
VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
+ VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
+ VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
+ VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
+ VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
+ VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
+ VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
+ VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
+ VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
+ VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
+ VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
+ VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
+ VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
+ VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
+ VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
@@ -1169,6 +1217,7 @@
VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
+ VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
@@ -1201,6 +1250,7 @@
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
+ VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
@@ -1282,6 +1332,7 @@
VK_INDEX_TYPE_UINT16 = 0,
VK_INDEX_TYPE_UINT32 = 1,
VK_INDEX_TYPE_NONE_NV = 1000165000,
+ VK_INDEX_TYPE_UINT8_EXT = 1000265000,
VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
@@ -1466,6 +1517,8 @@
VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
+ VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
+ VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryPropertyFlagBits;
typedef VkFlags VkMemoryPropertyFlags;
@@ -1619,6 +1672,10 @@
VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageViewCreateFlagBits;
typedef VkFlags VkImageViewCreateFlags;
+
+typedef enum VkShaderModuleCreateFlagBits {
+ VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkShaderModuleCreateFlagBits;
typedef VkFlags VkShaderModuleCreateFlags;
typedef VkFlags VkPipelineCacheCreateFlags;
@@ -1629,11 +1686,19 @@
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
+ VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
+ VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPipelineCreateFlagBits;
typedef VkFlags VkPipelineCreateFlags;
+
+typedef enum VkPipelineShaderStageCreateFlagBits {
+ VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
+ VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
+ VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineShaderStageCreateFlagBits;
typedef VkFlags VkPipelineShaderStageCreateFlags;
typedef enum VkShaderStageFlagBits {
@@ -1706,7 +1771,16 @@
} VkDescriptorPoolCreateFlagBits;
typedef VkFlags VkDescriptorPoolCreateFlags;
typedef VkFlags VkDescriptorPoolResetFlags;
+
+typedef enum VkFramebufferCreateFlagBits {
+ VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = 0x00000001,
+ VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFramebufferCreateFlagBits;
typedef VkFlags VkFramebufferCreateFlags;
+
+typedef enum VkRenderPassCreateFlagBits {
+ VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkRenderPassCreateFlagBits;
typedef VkFlags VkRenderPassCreateFlags;
typedef enum VkAttachmentDescriptionFlagBits {
@@ -1802,7 +1876,8 @@
typedef enum VkStencilFaceFlagBits {
VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
VK_STENCIL_FACE_BACK_BIT = 0x00000002,
- VK_STENCIL_FRONT_AND_BACK = 0x00000003,
+ VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
+ VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkStencilFaceFlagBits;
typedef VkFlags VkStencilFaceFlags;
@@ -5018,7 +5093,7 @@
#define VK_KHR_display 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
-#define VK_KHR_DISPLAY_SPEC_VERSION 21
+#define VK_KHR_DISPLAY_SPEC_VERSION 23
#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
@@ -5141,7 +5216,7 @@
#define VK_KHR_display_swapchain 1
-#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
+#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
typedef struct VkDisplayPresentInfoKHR {
VkStructureType sType;
@@ -5164,7 +5239,7 @@
#define VK_KHR_sampler_mirror_clamp_to_edge 1
-#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
@@ -5180,7 +5255,7 @@
#define VK_KHR_get_physical_device_properties2 1
-#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
@@ -5245,7 +5320,7 @@
#define VK_KHR_device_group 1
-#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3
+#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4
#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
@@ -5523,12 +5598,14 @@
#define VK_KHR_shader_float16_int8 1
#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
-typedef struct VkPhysicalDeviceFloat16Int8FeaturesKHR {
+typedef struct VkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 shaderFloat16;
VkBool32 shaderInt8;
-} VkPhysicalDeviceFloat16Int8FeaturesKHR;
+} VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
+
+typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR;
@@ -5599,6 +5676,43 @@
#endif
+#define VK_KHR_imageless_framebuffer 1
+#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
+#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
+typedef struct VkPhysicalDeviceImagelessFramebufferFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 imagelessFramebuffer;
+} VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
+
+typedef struct VkFramebufferAttachmentImageInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageCreateFlags flags;
+ VkImageUsageFlags usage;
+ uint32_t width;
+ uint32_t height;
+ uint32_t layerCount;
+ uint32_t viewFormatCount;
+ const VkFormat* pViewFormats;
+} VkFramebufferAttachmentImageInfoKHR;
+
+typedef struct VkFramebufferAttachmentsCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t attachmentImageInfoCount;
+ const VkFramebufferAttachmentImageInfoKHR* pAttachmentImageInfos;
+} VkFramebufferAttachmentsCreateInfoKHR;
+
+typedef struct VkRenderPassAttachmentBeginInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t attachmentCount;
+ const VkImageView* pAttachments;
+} VkRenderPassAttachmentBeginInfoKHR;
+
+
+
#define VK_KHR_create_renderpass2 1
#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
@@ -5991,7 +6105,7 @@
#define VK_KHR_sampler_ycbcr_conversion 1
typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
-#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
@@ -6095,6 +6209,17 @@
#endif
+#define VK_KHR_shader_subgroup_extended_types 1
+#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1
+#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
+typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 shaderSubgroupExtendedTypes;
+} VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+
+
+
#define VK_KHR_8bit_storage 1
#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1
#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
@@ -6120,6 +6245,18 @@
+#define VK_KHR_shader_clock 1
+#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1
+#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
+typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 shaderSubgroupClock;
+ VkBool32 shaderDeviceClock;
+} VkPhysicalDeviceShaderClockFeaturesKHR;
+
+
+
#define VK_KHR_driver_properties 1
#define VK_MAX_DRIVER_NAME_SIZE_KHR 256
#define VK_MAX_DRIVER_INFO_SIZE_KHR 256
@@ -6138,9 +6275,10 @@
VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9,
VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = 10,
VK_DRIVER_ID_GGP_PROPRIETARY_KHR = 11,
+ VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = 12,
VK_DRIVER_ID_BEGIN_RANGE_KHR = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
- VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_GGP_PROPRIETARY_KHR,
- VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_GGP_PROPRIETARY_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1),
+ VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR,
+ VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1),
VK_DRIVER_ID_MAX_ENUM_KHR = 0x7FFFFFFF
} VkDriverIdKHR;
typedef struct VkConformanceVersionKHR {
@@ -6162,28 +6300,38 @@
#define VK_KHR_shader_float_controls 1
-#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
+
+typedef enum VkShaderFloatControlsIndependenceKHR {
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = 0,
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = 1,
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = 2,
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_BEGIN_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR,
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_END_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR,
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_RANGE_SIZE_KHR = (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR + 1),
+ VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkShaderFloatControlsIndependenceKHR;
typedef struct VkPhysicalDeviceFloatControlsPropertiesKHR {
- VkStructureType sType;
- void* pNext;
- VkBool32 separateDenormSettings;
- VkBool32 separateRoundingModeSettings;
- VkBool32 shaderSignedZeroInfNanPreserveFloat16;
- VkBool32 shaderSignedZeroInfNanPreserveFloat32;
- VkBool32 shaderSignedZeroInfNanPreserveFloat64;
- VkBool32 shaderDenormPreserveFloat16;
- VkBool32 shaderDenormPreserveFloat32;
- VkBool32 shaderDenormPreserveFloat64;
- VkBool32 shaderDenormFlushToZeroFloat16;
- VkBool32 shaderDenormFlushToZeroFloat32;
- VkBool32 shaderDenormFlushToZeroFloat64;
- VkBool32 shaderRoundingModeRTEFloat16;
- VkBool32 shaderRoundingModeRTEFloat32;
- VkBool32 shaderRoundingModeRTEFloat64;
- VkBool32 shaderRoundingModeRTZFloat16;
- VkBool32 shaderRoundingModeRTZFloat32;
- VkBool32 shaderRoundingModeRTZFloat64;
+ VkStructureType sType;
+ void* pNext;
+ VkShaderFloatControlsIndependenceKHR denormBehaviorIndependence;
+ VkShaderFloatControlsIndependenceKHR roundingModeIndependence;
+ VkBool32 shaderSignedZeroInfNanPreserveFloat16;
+ VkBool32 shaderSignedZeroInfNanPreserveFloat32;
+ VkBool32 shaderSignedZeroInfNanPreserveFloat64;
+ VkBool32 shaderDenormPreserveFloat16;
+ VkBool32 shaderDenormPreserveFloat32;
+ VkBool32 shaderDenormPreserveFloat64;
+ VkBool32 shaderDenormFlushToZeroFloat16;
+ VkBool32 shaderDenormFlushToZeroFloat32;
+ VkBool32 shaderDenormFlushToZeroFloat64;
+ VkBool32 shaderRoundingModeRTEFloat16;
+ VkBool32 shaderRoundingModeRTEFloat32;
+ VkBool32 shaderRoundingModeRTEFloat64;
+ VkBool32 shaderRoundingModeRTZFloat16;
+ VkBool32 shaderRoundingModeRTZFloat32;
+ VkBool32 shaderRoundingModeRTZFloat64;
} VkPhysicalDeviceFloatControlsPropertiesKHR;
@@ -6225,6 +6373,89 @@
#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
+#define VK_KHR_timeline_semaphore 1
+#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2
+#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"
+
+typedef enum VkSemaphoreTypeKHR {
+ VK_SEMAPHORE_TYPE_BINARY_KHR = 0,
+ VK_SEMAPHORE_TYPE_TIMELINE_KHR = 1,
+ VK_SEMAPHORE_TYPE_BEGIN_RANGE_KHR = VK_SEMAPHORE_TYPE_BINARY_KHR,
+ VK_SEMAPHORE_TYPE_END_RANGE_KHR = VK_SEMAPHORE_TYPE_TIMELINE_KHR,
+ VK_SEMAPHORE_TYPE_RANGE_SIZE_KHR = (VK_SEMAPHORE_TYPE_TIMELINE_KHR - VK_SEMAPHORE_TYPE_BINARY_KHR + 1),
+ VK_SEMAPHORE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSemaphoreTypeKHR;
+
+typedef enum VkSemaphoreWaitFlagBitsKHR {
+ VK_SEMAPHORE_WAIT_ANY_BIT_KHR = 0x00000001,
+ VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSemaphoreWaitFlagBitsKHR;
+typedef VkFlags VkSemaphoreWaitFlagsKHR;
+typedef struct VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 timelineSemaphore;
+} VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
+
+typedef struct VkPhysicalDeviceTimelineSemaphorePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ uint64_t maxTimelineSemaphoreValueDifference;
+} VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
+
+typedef struct VkSemaphoreTypeCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphoreTypeKHR semaphoreType;
+ uint64_t initialValue;
+} VkSemaphoreTypeCreateInfoKHR;
+
+typedef struct VkTimelineSemaphoreSubmitInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreValueCount;
+ const uint64_t* pWaitSemaphoreValues;
+ uint32_t signalSemaphoreValueCount;
+ const uint64_t* pSignalSemaphoreValues;
+} VkTimelineSemaphoreSubmitInfoKHR;
+
+typedef struct VkSemaphoreWaitInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphoreWaitFlagsKHR flags;
+ uint32_t semaphoreCount;
+ const VkSemaphore* pSemaphores;
+ const uint64_t* pValues;
+} VkSemaphoreWaitInfoKHR;
+
+typedef struct VkSemaphoreSignalInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphore semaphore;
+ uint64_t value;
+} VkSemaphoreSignalInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
+typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout);
+typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(
+ VkDevice device,
+ VkSemaphore semaphore,
+ uint64_t* pValue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(
+ VkDevice device,
+ const VkSemaphoreWaitInfoKHR* pWaitInfo,
+ uint64_t timeout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(
+ VkDevice device,
+ const VkSemaphoreSignalInfoKHR* pSignalInfo);
+#endif
+
+
#define VK_KHR_vulkan_memory_model 1
#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
@@ -6238,6 +6469,11 @@
+#define VK_KHR_spirv_1_4 1
+#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1
+#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4"
+
+
#define VK_KHR_surface_protected_capabilities 1
#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
@@ -6260,6 +6496,99 @@
+#define VK_KHR_pipeline_executable_properties 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
+#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
+
+typedef enum VkPipelineExecutableStatisticFormatKHR {
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BEGIN_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_END_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR,
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_RANGE_SIZE_KHR = (VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR + 1),
+ VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPipelineExecutableStatisticFormatKHR;
+typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 pipelineExecutableInfo;
+} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
+
+typedef struct VkPipelineInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+} VkPipelineInfoKHR;
+
+typedef struct VkPipelineExecutablePropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkShaderStageFlags stages;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ uint32_t subgroupSize;
+} VkPipelineExecutablePropertiesKHR;
+
+typedef struct VkPipelineExecutableInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipeline pipeline;
+ uint32_t executableIndex;
+} VkPipelineExecutableInfoKHR;
+
+typedef union VkPipelineExecutableStatisticValueKHR {
+ VkBool32 b32;
+ int64_t i64;
+ uint64_t u64;
+ double f64;
+} VkPipelineExecutableStatisticValueKHR;
+
+typedef struct VkPipelineExecutableStatisticKHR {
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkPipelineExecutableStatisticFormatKHR format;
+ VkPipelineExecutableStatisticValueKHR value;
+} VkPipelineExecutableStatisticKHR;
+
+typedef struct VkPipelineExecutableInternalRepresentationKHR {
+ VkStructureType sType;
+ void* pNext;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ VkBool32 isText;
+ size_t dataSize;
+ void* pData;
+} VkPipelineExecutableInternalRepresentationKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
+ VkDevice device,
+ const VkPipelineInfoKHR* pPipelineInfo,
+ uint32_t* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
+ VkDevice device,
+ const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ uint32_t* pStatisticCount,
+ VkPipelineExecutableStatisticKHR* pStatistics);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
+ VkDevice device,
+ const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ uint32_t* pInternalRepresentationCount,
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+#endif
+
+
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9
@@ -6379,7 +6708,7 @@
#define VK_IMG_filter_cubic 1
-#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 2
+#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1
#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
@@ -6606,7 +6935,7 @@
#define VK_AMD_draw_indirect_count 1
-#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
+#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
@@ -6783,7 +7112,7 @@
#define VK_EXT_validation_flags 1
-#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
+#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2
#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
typedef enum VkValidationCheckEXT {
@@ -6813,6 +7142,17 @@
#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
+#define VK_EXT_texture_compression_astc_hdr 1
+#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
+#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
+typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 textureCompressionASTC_HDR;
+} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+
+
+
#define VK_EXT_astc_decode_mode 1
#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
@@ -6831,7 +7171,7 @@
#define VK_EXT_conditional_rendering 1
-#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
+#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
typedef enum VkConditionalRenderingFlagBitsEXT {
@@ -7463,7 +7803,7 @@
#define VK_EXT_hdr_metadata 1
-#define VK_EXT_HDR_METADATA_SPEC_VERSION 1
+#define VK_EXT_HDR_METADATA_SPEC_VERSION 2
#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
typedef struct VkXYColorEXT {
float x;
@@ -7647,7 +7987,7 @@
#define VK_EXT_sampler_filter_minmax 1
-#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
+#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
typedef enum VkSamplerReductionModeEXT {
@@ -8230,6 +8570,15 @@
#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing"
#define VK_SHADER_UNUSED_NV (~0U)
+typedef enum VkAccelerationStructureTypeNV {
+ VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
+ VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
+ VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
+ VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
+ VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1),
+ VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkAccelerationStructureTypeNV;
+
typedef enum VkRayTracingShaderGroupTypeNV {
VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0,
VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1,
@@ -8249,15 +8598,6 @@
VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
} VkGeometryTypeNV;
-typedef enum VkAccelerationStructureTypeNV {
- VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
- VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
- VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
- VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
- VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1),
- VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
-} VkAccelerationStructureTypeNV;
-
typedef enum VkCopyAccelerationStructureModeNV {
VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0,
VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1,
@@ -8525,7 +8865,7 @@
#define VK_NV_representative_fragment_test 1
-#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1
+#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
VkStructureType sType;
@@ -8542,7 +8882,7 @@
#define VK_EXT_filter_cubic 1
-#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 1
+#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 2
#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
VkStructureType sType;
@@ -8629,6 +8969,22 @@
#endif
+#define VK_AMD_pipeline_compiler_control 1
+#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
+#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
+
+typedef enum VkPipelineCompilerControlFlagBitsAMD {
+ VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkPipelineCompilerControlFlagBitsAMD;
+typedef VkFlags VkPipelineCompilerControlFlagsAMD;
+typedef struct VkPipelineCompilerControlCreateInfoAMD {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCompilerControlFlagsAMD compilerControlFlags;
+} VkPipelineCompilerControlCreateInfoAMD;
+
+
+
#define VK_EXT_calibrated_timestamps 1
#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
@@ -8668,7 +9024,7 @@
#define VK_AMD_shader_core_properties 1
-#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
VkStructureType sType;
@@ -8858,7 +9214,7 @@
#define VK_NV_shader_image_footprint 1
-#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1
+#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
VkStructureType sType;
@@ -8927,13 +9283,13 @@
#define VK_INTEL_shader_integer_functions2 1
-#define VK_INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION 1
-#define VK_INTEL_SHADER_INTEGER_FUNCTIONS2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
-typedef struct VkPhysicalDeviceShaderIntegerFunctions2INTEL {
+#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
+#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
+typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
VkStructureType sType;
void* pNext;
VkBool32 shaderIntegerFunctions2;
-} VkPhysicalDeviceShaderIntegerFunctions2INTEL;
+} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
@@ -9175,6 +9531,61 @@
#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
+#define VK_EXT_subgroup_size_control 1
+#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
+#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
+typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 subgroupSizeControl;
+ VkBool32 computeFullSubgroups;
+} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
+
+typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t minSubgroupSize;
+ uint32_t maxSubgroupSize;
+ uint32_t maxComputeWorkgroupSubgroups;
+ VkShaderStageFlags requiredSubgroupSizeStages;
+} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
+
+typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t requiredSubgroupSize;
+} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+
+
+
+#define VK_AMD_shader_core_properties2 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
+
+typedef enum VkShaderCorePropertiesFlagBitsAMD {
+ VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkShaderCorePropertiesFlagBitsAMD;
+typedef VkFlags VkShaderCorePropertiesFlagsAMD;
+typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
+ VkStructureType sType;
+ void* pNext;
+ VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+ uint32_t activeComputeUnitCount;
+} VkPhysicalDeviceShaderCoreProperties2AMD;
+
+
+
+#define VK_AMD_device_coherent_memory 1
+#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
+#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
+typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 deviceCoherentMemory;
+} VkPhysicalDeviceCoherentMemoryFeaturesAMD;
+
+
+
#define VK_EXT_memory_budget 1
#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
@@ -9262,15 +9673,16 @@
#define VK_EXT_validation_features 1
-#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 1
+#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 2
#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
typedef enum VkValidationFeatureEnableEXT {
VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
+ VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
- VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,
- VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
+ VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
+ VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkValidationFeatureEnableEXT;
@@ -9436,7 +9848,7 @@
#define VK_EXT_headless_surface 1
-#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 0
+#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1
#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
typedef struct VkHeadlessSurfaceCreateInfoEXT {
@@ -9456,6 +9868,56 @@
#endif
+#define VK_EXT_line_rasterization 1
+#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
+#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
+
+typedef enum VkLineRasterizationModeEXT {
+ VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
+ VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
+ VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
+ VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
+ VK_LINE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
+ VK_LINE_RASTERIZATION_MODE_END_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT,
+ VK_LINE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT + 1),
+ VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkLineRasterizationModeEXT;
+typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 rectangularLines;
+ VkBool32 bresenhamLines;
+ VkBool32 smoothLines;
+ VkBool32 stippledRectangularLines;
+ VkBool32 stippledBresenhamLines;
+ VkBool32 stippledSmoothLines;
+} VkPhysicalDeviceLineRasterizationFeaturesEXT;
+
+typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t lineSubPixelPrecisionBits;
+} VkPhysicalDeviceLineRasterizationPropertiesEXT;
+
+typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkLineRasterizationModeEXT lineRasterizationMode;
+ VkBool32 stippledLineEnable;
+ uint32_t lineStippleFactor;
+ uint16_t lineStipplePattern;
+} VkPipelineRasterizationLineStateCreateInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern);
+#endif
+
+
#define VK_EXT_host_query_reset 1
#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
@@ -9475,6 +9937,53 @@
uint32_t queryCount);
#endif
+
+#define VK_EXT_index_type_uint8 1
+#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
+#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
+typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 indexTypeUint8;
+} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
+
+
+
+#define VK_EXT_shader_demote_to_helper_invocation 1
+#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
+#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
+typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 shaderDemoteToHelperInvocation;
+} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+
+
+
+#define VK_EXT_texel_buffer_alignment 1
+#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
+#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
+typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 texelBufferAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
+
+typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
+ VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+ VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
+ VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+
+
+
+#define VK_GOOGLE_user_type 1
+#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1
+#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
+
#ifdef __cplusplus
}
#endif
diff --git a/include/vulkan/vulkan_fuchsia.h b/include/vulkan/vulkan_fuchsia.h
index 52b202c..bc8aaa8 100644
--- a/include/vulkan/vulkan_fuchsia.h
+++ b/include/vulkan/vulkan_fuchsia.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_FUCHSIA_H_
#define VULKAN_FUCHSIA_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_FUCHSIA_imagepipe_surface 1
#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
diff --git a/include/vulkan/vulkan_ggp.h b/include/vulkan/vulkan_ggp.h
index 1082c83..32f9c2a 100644
--- a/include/vulkan/vulkan_ggp.h
+++ b/include/vulkan/vulkan_ggp.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_GGP_H_
#define VULKAN_GGP_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_GGP_stream_descriptor_surface 1
#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
diff --git a/include/vulkan/vulkan_ios.h b/include/vulkan/vulkan_ios.h
index b37ebfe..bc2c361 100644
--- a/include/vulkan/vulkan_ios.h
+++ b/include/vulkan/vulkan_ios.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_IOS_H_
#define VULKAN_IOS_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_MVK_ios_surface 1
#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2
diff --git a/include/vulkan/vulkan_macos.h b/include/vulkan/vulkan_macos.h
index ebcf3bf..9c38230 100644
--- a/include/vulkan/vulkan_macos.h
+++ b/include/vulkan/vulkan_macos.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_MACOS_H_
#define VULKAN_MACOS_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_MVK_macos_surface 1
#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
diff --git a/include/vulkan/vulkan_metal.h b/include/vulkan/vulkan_metal.h
index a17f1dd..454c46c 100644
--- a/include/vulkan/vulkan_metal.h
+++ b/include/vulkan/vulkan_metal.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_METAL_H_
#define VULKAN_METAL_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_EXT_metal_surface 1
diff --git a/include/vulkan/vulkan_vi.h b/include/vulkan/vulkan_vi.h
index c0b9103..a13ca36 100644
--- a/include/vulkan/vulkan_vi.h
+++ b/include/vulkan/vulkan_vi.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_VI_H_
#define VULKAN_VI_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_NN_vi_surface 1
#define VK_NN_VI_SURFACE_SPEC_VERSION 1
diff --git a/include/vulkan/vulkan_wayland.h b/include/vulkan/vulkan_wayland.h
index dc9751f..e1c784c 100644
--- a/include/vulkan/vulkan_wayland.h
+++ b/include/vulkan/vulkan_wayland.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_WAYLAND_H_
#define VULKAN_WAYLAND_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_KHR_wayland_surface 1
#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
diff --git a/include/vulkan/vulkan_win32.h b/include/vulkan/vulkan_win32.h
index da53137..d87db5f 100644
--- a/include/vulkan/vulkan_win32.h
+++ b/include/vulkan/vulkan_win32.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_WIN32_H_
#define VULKAN_WIN32_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_KHR_win32_surface 1
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
@@ -246,7 +247,7 @@
#define VK_NV_win32_keyed_mutex 1
-#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
VkStructureType sType;
@@ -263,7 +264,7 @@
#define VK_EXT_full_screen_exclusive 1
-#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 3
+#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
typedef enum VkFullScreenExclusiveEXT {
diff --git a/include/vulkan/vulkan_xcb.h b/include/vulkan/vulkan_xcb.h
index e0a9635..1470e25 100644
--- a/include/vulkan/vulkan_xcb.h
+++ b/include/vulkan/vulkan_xcb.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_XCB_H_
#define VULKAN_XCB_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_KHR_xcb_surface 1
#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6
diff --git a/include/vulkan/vulkan_xlib.h b/include/vulkan/vulkan_xlib.h
index c16b53b..46f35f2 100644
--- a/include/vulkan/vulkan_xlib.h
+++ b/include/vulkan/vulkan_xlib.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_XLIB_H_
#define VULKAN_XLIB_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_KHR_xlib_surface 1
#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6
diff --git a/include/vulkan/vulkan_xlib_xrandr.h b/include/vulkan/vulkan_xlib_xrandr.h
index c95aba9..dcc4722 100644
--- a/include/vulkan/vulkan_xlib_xrandr.h
+++ b/include/vulkan/vulkan_xlib_xrandr.h
@@ -1,10 +1,6 @@
#ifndef VULKAN_XLIB_XRANDR_H_
#define VULKAN_XLIB_XRANDR_H_ 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
** Copyright (c) 2015-2019 The Khronos Group Inc.
**
@@ -27,6 +23,11 @@
*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
#define VK_EXT_acquire_xlib_display 1
#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
