// This header is generated from the Khronos Vulkan XML API Registry.
-
#ifndef VULKAN_HPP
#define VULKAN_HPP
# include <memory>
# include <vector>
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-static_assert( VK_HEADER_VERSION == 49 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 50 , "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
namespace vk
{
+
template <typename FlagBitsType> struct FlagTraits
{
enum { allFlags = 0 };
private:
MaskType m_mask;
};
-
+
template <typename BitType>
Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags)
{
return flags | bit;
}
-
+
template <typename BitType>
Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags)
{
return flags & bit;
}
-
+
template <typename BitType>
Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags)
{
};
#endif
-
#if defined(VULKAN_HPP_NO_EXCEPTIONS) && !defined(VULKAN_HPP_NO_SMART_HANDLE)
# define VULKAN_HPP_NO_SMART_HANDLE
#endif
}
}
+
#if defined(_MSC_VER) && (_MSC_VER == 1800)
# define noexcept _NOEXCEPT
#endif
return std::error_condition(static_cast<int>(e), errorCategory());
}
+#if defined(_MSC_VER) && (_MSC_VER == 1800)
+# define noexcept _NOEXCEPT
+#endif
+
+ class Error
+ {
+ public:
+ virtual ~Error() = default;
+
+ virtual const char* what() const noexcept = 0;
+ };
+
+ class LogicError : public Error, public std::logic_error
+ {
+ public:
+ explicit LogicError( const std::string& what )
+ : Error(), std::logic_error(what) {}
+ explicit LogicError( char const * what )
+ : Error(), std::logic_error(what) {}
+ virtual ~LogicError() = default;
+
+ virtual const char* what() const noexcept { return std::logic_error::what(); }
+ };
+
+ class SystemError : public Error, public std::system_error
+ {
+ public:
+ SystemError( std::error_code ec )
+ : Error(), std::system_error(ec) {}
+ SystemError( std::error_code ec, std::string const& what )
+ : Error(), std::system_error(ec, what) {}
+ SystemError( std::error_code ec, char const * what )
+ : Error(), std::system_error(ec, what) {}
+ SystemError( int ev, std::error_category const& ecat )
+ : Error(), std::system_error(ev, ecat) {}
+ SystemError( int ev, std::error_category const& ecat, std::string const& what)
+ : Error(), std::system_error(ev, ecat, what) {}
+ SystemError( int ev, std::error_category const& ecat, char const * what)
+ : Error(), std::system_error(ev, ecat, what) {}
+ virtual ~SystemError() = default;
+
+ virtual const char* what() const noexcept { return std::system_error::what(); }
+ };
+
+#if defined(_MSC_VER) && (_MSC_VER == 1800)
+# undef noexcept
+#endif
+
+ class OutOfHostMemoryError : public SystemError
+ {
+ public:
+ OutOfHostMemoryError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
+ OutOfHostMemoryError( char const * message )
+ : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
+ };
+ class OutOfDeviceMemoryError : public SystemError
+ {
+ public:
+ OutOfDeviceMemoryError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
+ OutOfDeviceMemoryError( char const * message )
+ : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
+ };
+ class InitializationFailedError : public SystemError
+ {
+ public:
+ InitializationFailedError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
+ InitializationFailedError( char const * message )
+ : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
+ };
+ class DeviceLostError : public SystemError
+ {
+ public:
+ DeviceLostError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
+ DeviceLostError( char const * message )
+ : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
+ };
+ class MemoryMapFailedError : public SystemError
+ {
+ public:
+ MemoryMapFailedError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
+ MemoryMapFailedError( char const * message )
+ : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
+ };
+ class LayerNotPresentError : public SystemError
+ {
+ public:
+ LayerNotPresentError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
+ LayerNotPresentError( char const * message )
+ : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
+ };
+ class ExtensionNotPresentError : public SystemError
+ {
+ public:
+ ExtensionNotPresentError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
+ ExtensionNotPresentError( char const * message )
+ : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
+ };
+ class FeatureNotPresentError : public SystemError
+ {
+ public:
+ FeatureNotPresentError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
+ FeatureNotPresentError( char const * message )
+ : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
+ };
+ class IncompatibleDriverError : public SystemError
+ {
+ public:
+ IncompatibleDriverError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
+ IncompatibleDriverError( char const * message )
+ : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
+ };
+ class TooManyObjectsError : public SystemError
+ {
+ public:
+ TooManyObjectsError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
+ TooManyObjectsError( char const * message )
+ : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
+ };
+ class FormatNotSupportedError : public SystemError
+ {
+ public:
+ FormatNotSupportedError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
+ FormatNotSupportedError( char const * message )
+ : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
+ };
+ class FragmentedPoolError : public SystemError
+ {
+ public:
+ FragmentedPoolError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
+ FragmentedPoolError( char const * message )
+ : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
+ };
+ class SurfaceLostKHRError : public SystemError
+ {
+ public:
+ SurfaceLostKHRError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
+ SurfaceLostKHRError( char const * message )
+ : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
+ };
+ class NativeWindowInUseKHRError : public SystemError
+ {
+ public:
+ NativeWindowInUseKHRError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
+ NativeWindowInUseKHRError( char const * message )
+ : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
+ };
+ class OutOfDateKHRError : public SystemError
+ {
+ public:
+ OutOfDateKHRError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
+ OutOfDateKHRError( char const * message )
+ : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
+ };
+ class IncompatibleDisplayKHRError : public SystemError
+ {
+ public:
+ IncompatibleDisplayKHRError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
+ IncompatibleDisplayKHRError( char const * message )
+ : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
+ };
+ class ValidationFailedEXTError : public SystemError
+ {
+ public:
+ ValidationFailedEXTError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
+ ValidationFailedEXTError( char const * message )
+ : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
+ };
+ class InvalidShaderNVError : public SystemError
+ {
+ public:
+ InvalidShaderNVError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
+ InvalidShaderNVError( char const * message )
+ : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
+ };
+ class OutOfPoolMemoryKHRError : public SystemError
+ {
+ public:
+ OutOfPoolMemoryKHRError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {}
+ OutOfPoolMemoryKHRError( char const * message )
+ : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {}
+ };
+ class InvalidExternalHandleKHXError : public SystemError
+ {
+ public:
+ InvalidExternalHandleKHXError( std::string const& message )
+ : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHX ), message ) {}
+ InvalidExternalHandleKHXError( char const * message )
+ : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHX ), message ) {}
+ };
+
+ VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
+ {
+ assert ( static_cast<long long int>(result) < 0 );
+ switch ( result )
+ {
+ case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message );
+ case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message );
+ case Result::eErrorInitializationFailed: throw InitializationFailedError ( message );
+ case Result::eErrorDeviceLost: throw DeviceLostError ( message );
+ case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message );
+ case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message );
+ case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message );
+ case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message );
+ case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message );
+ case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message );
+ case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message );
+ case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message );
+ case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message );
+ case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message );
+ case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message );
+ case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message );
+ case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message );
+ case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message );
+ case Result::eErrorOutOfPoolMemoryKHR: throw OutOfPoolMemoryKHRError ( message );
+ case Result::eErrorInvalidExternalHandleKHX: throw InvalidExternalHandleKHXError ( message );
+ default: throw SystemError( make_error_code( result ) );
+ }
+ }
+
} // namespace vk
namespace std
namespace vk
{
+
template <typename T>
struct ResultValue
{
#endif
};
- template <> struct ResultValueType<void>
+ template <>
+ struct ResultValueType<void>
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
typedef Result type;
#else
if ( result != Result::eSuccess )
{
- throw std::system_error( result, message );
+ throwResultException( result, message );
}
#endif
}
#else
if ( result != Result::eSuccess )
{
- throw std::system_error( result, message );
+ throwResultException( result, message );
}
return data;
#endif
#else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
- throw std::system_error( result, message );
+ throwResultException( result, message );
}
#endif
return result;
#else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
- throw std::system_error( result, message );
+ throwResultException( result, message );
}
#endif
return ResultValue<T>( result, data );
using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
- VULKAN_HPP_INLINE FramebufferCreateFlags operator|( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 )
- {
- return FramebufferCreateFlags( bit0 ) | bit1;
- }
-
enum class QueryPoolCreateFlagBits
{
};
using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;
- VULKAN_HPP_INLINE QueryPoolCreateFlags operator|( QueryPoolCreateFlagBits bit0, QueryPoolCreateFlagBits bit1 )
- {
- return QueryPoolCreateFlags( bit0 ) | bit1;
- }
-
enum class RenderPassCreateFlagBits
{
};
using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;
- VULKAN_HPP_INLINE RenderPassCreateFlags operator|( RenderPassCreateFlagBits bit0, RenderPassCreateFlagBits bit1 )
- {
- return RenderPassCreateFlags( bit0 ) | bit1;
- }
-
enum class SamplerCreateFlagBits
{
};
using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
- VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 )
- {
- return SamplerCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineLayoutCreateFlagBits
{
};
using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;
- VULKAN_HPP_INLINE PipelineLayoutCreateFlags operator|( PipelineLayoutCreateFlagBits bit0, PipelineLayoutCreateFlagBits bit1 )
- {
- return PipelineLayoutCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineCacheCreateFlagBits
{
};
using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;
- VULKAN_HPP_INLINE PipelineCacheCreateFlags operator|( PipelineCacheCreateFlagBits bit0, PipelineCacheCreateFlagBits bit1 )
- {
- return PipelineCacheCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineDepthStencilStateCreateFlagBits
{
};
using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineDepthStencilStateCreateFlags operator|( PipelineDepthStencilStateCreateFlagBits bit0, PipelineDepthStencilStateCreateFlagBits bit1 )
- {
- return PipelineDepthStencilStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineDynamicStateCreateFlagBits
{
};
using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineDynamicStateCreateFlags operator|( PipelineDynamicStateCreateFlagBits bit0, PipelineDynamicStateCreateFlagBits bit1 )
- {
- return PipelineDynamicStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineColorBlendStateCreateFlagBits
{
};
using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineColorBlendStateCreateFlags operator|( PipelineColorBlendStateCreateFlagBits bit0, PipelineColorBlendStateCreateFlagBits bit1 )
- {
- return PipelineColorBlendStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineMultisampleStateCreateFlagBits
{
};
using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineMultisampleStateCreateFlags operator|( PipelineMultisampleStateCreateFlagBits bit0, PipelineMultisampleStateCreateFlagBits bit1 )
- {
- return PipelineMultisampleStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineRasterizationStateCreateFlagBits
{
};
using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineRasterizationStateCreateFlags operator|( PipelineRasterizationStateCreateFlagBits bit0, PipelineRasterizationStateCreateFlagBits bit1 )
- {
- return PipelineRasterizationStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineViewportStateCreateFlagBits
{
};
using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineViewportStateCreateFlags operator|( PipelineViewportStateCreateFlagBits bit0, PipelineViewportStateCreateFlagBits bit1 )
- {
- return PipelineViewportStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineTessellationStateCreateFlagBits
{
};
using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineTessellationStateCreateFlags operator|( PipelineTessellationStateCreateFlagBits bit0, PipelineTessellationStateCreateFlagBits bit1 )
- {
- return PipelineTessellationStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineInputAssemblyStateCreateFlagBits
{
};
using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineInputAssemblyStateCreateFlags operator|( PipelineInputAssemblyStateCreateFlagBits bit0, PipelineInputAssemblyStateCreateFlagBits bit1 )
- {
- return PipelineInputAssemblyStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineVertexInputStateCreateFlagBits
{
};
using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;
- VULKAN_HPP_INLINE PipelineVertexInputStateCreateFlags operator|( PipelineVertexInputStateCreateFlagBits bit0, PipelineVertexInputStateCreateFlagBits bit1 )
- {
- return PipelineVertexInputStateCreateFlags( bit0 ) | bit1;
- }
-
enum class PipelineShaderStageCreateFlagBits
{
};
using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
- VULKAN_HPP_INLINE PipelineShaderStageCreateFlags operator|( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 )
- {
- return PipelineShaderStageCreateFlags( bit0 ) | bit1;
- }
-
enum class BufferViewCreateFlagBits
{
};
using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
- VULKAN_HPP_INLINE BufferViewCreateFlags operator|( BufferViewCreateFlagBits bit0, BufferViewCreateFlagBits bit1 )
- {
- return BufferViewCreateFlags( bit0 ) | bit1;
- }
-
enum class InstanceCreateFlagBits
{
};
using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;
- VULKAN_HPP_INLINE InstanceCreateFlags operator|( InstanceCreateFlagBits bit0, InstanceCreateFlagBits bit1 )
- {
- return InstanceCreateFlags( bit0 ) | bit1;
- }
-
enum class DeviceCreateFlagBits
{
};
using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;
- VULKAN_HPP_INLINE DeviceCreateFlags operator|( DeviceCreateFlagBits bit0, DeviceCreateFlagBits bit1 )
- {
- return DeviceCreateFlags( bit0 ) | bit1;
- }
-
enum class DeviceQueueCreateFlagBits
{
};
using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
- VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 )
- {
- return DeviceQueueCreateFlags( bit0 ) | bit1;
- }
-
enum class ImageViewCreateFlagBits
{
};
using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
- VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 )
- {
- return ImageViewCreateFlags( bit0 ) | bit1;
- }
-
enum class SemaphoreCreateFlagBits
{
};
using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;
- VULKAN_HPP_INLINE SemaphoreCreateFlags operator|( SemaphoreCreateFlagBits bit0, SemaphoreCreateFlagBits bit1 )
- {
- return SemaphoreCreateFlags( bit0 ) | bit1;
- }
-
enum class ShaderModuleCreateFlagBits
{
};
using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;
- VULKAN_HPP_INLINE ShaderModuleCreateFlags operator|( ShaderModuleCreateFlagBits bit0, ShaderModuleCreateFlagBits bit1 )
- {
- return ShaderModuleCreateFlags( bit0 ) | bit1;
- }
-
enum class EventCreateFlagBits
{
};
using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;
- VULKAN_HPP_INLINE EventCreateFlags operator|( EventCreateFlagBits bit0, EventCreateFlagBits bit1 )
- {
- return EventCreateFlags( bit0 ) | bit1;
- }
-
enum class MemoryMapFlagBits
{
};
using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;
- VULKAN_HPP_INLINE MemoryMapFlags operator|( MemoryMapFlagBits bit0, MemoryMapFlagBits bit1 )
- {
- return MemoryMapFlags( bit0 ) | bit1;
- }
-
enum class DescriptorPoolResetFlagBits
{
};
using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;
- VULKAN_HPP_INLINE DescriptorPoolResetFlags operator|( DescriptorPoolResetFlagBits bit0, DescriptorPoolResetFlagBits bit1 )
- {
- return DescriptorPoolResetFlags( bit0 ) | bit1;
- }
-
enum class DescriptorUpdateTemplateCreateFlagBitsKHR
{
};
using DescriptorUpdateTemplateCreateFlagsKHR = Flags<DescriptorUpdateTemplateCreateFlagBitsKHR, VkDescriptorUpdateTemplateCreateFlagsKHR>;
- VULKAN_HPP_INLINE DescriptorUpdateTemplateCreateFlagsKHR operator|( DescriptorUpdateTemplateCreateFlagBitsKHR bit0, DescriptorUpdateTemplateCreateFlagBitsKHR bit1 )
- {
- return DescriptorUpdateTemplateCreateFlagsKHR( bit0 ) | bit1;
- }
-
enum class DisplayModeCreateFlagBitsKHR
{
};
using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;
- VULKAN_HPP_INLINE DisplayModeCreateFlagsKHR operator|( DisplayModeCreateFlagBitsKHR bit0, DisplayModeCreateFlagBitsKHR bit1 )
- {
- return DisplayModeCreateFlagsKHR( bit0 ) | bit1;
- }
-
enum class DisplaySurfaceCreateFlagBitsKHR
{
};
using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;
- VULKAN_HPP_INLINE DisplaySurfaceCreateFlagsKHR operator|( DisplaySurfaceCreateFlagBitsKHR bit0, DisplaySurfaceCreateFlagBitsKHR bit1 )
- {
- return DisplaySurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
-
#ifdef VK_USE_PLATFORM_ANDROID_KHR
enum class AndroidSurfaceCreateFlagBitsKHR
{
#ifdef VK_USE_PLATFORM_ANDROID_KHR
using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
-
- VULKAN_HPP_INLINE AndroidSurfaceCreateFlagsKHR operator|( AndroidSurfaceCreateFlagBitsKHR bit0, AndroidSurfaceCreateFlagBitsKHR bit1 )
- {
- return AndroidSurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#ifdef VK_USE_PLATFORM_MIR_KHR
#ifdef VK_USE_PLATFORM_MIR_KHR
using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>;
-
- VULKAN_HPP_INLINE MirSurfaceCreateFlagsKHR operator|( MirSurfaceCreateFlagBitsKHR bit0, MirSurfaceCreateFlagBitsKHR bit1 )
- {
- return MirSurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_MIR_KHR*/
#ifdef VK_USE_PLATFORM_VI_NN
#ifdef VK_USE_PLATFORM_VI_NN
using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>;
-
- VULKAN_HPP_INLINE ViSurfaceCreateFlagsNN operator|( ViSurfaceCreateFlagBitsNN bit0, ViSurfaceCreateFlagBitsNN bit1 )
- {
- return ViSurfaceCreateFlagsNN( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_VI_NN*/
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
-
- VULKAN_HPP_INLINE WaylandSurfaceCreateFlagsKHR operator|( WaylandSurfaceCreateFlagBitsKHR bit0, WaylandSurfaceCreateFlagBitsKHR bit1 )
- {
- return WaylandSurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#ifdef VK_USE_PLATFORM_WIN32_KHR
#ifdef VK_USE_PLATFORM_WIN32_KHR
using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
-
- VULKAN_HPP_INLINE Win32SurfaceCreateFlagsKHR operator|( Win32SurfaceCreateFlagBitsKHR bit0, Win32SurfaceCreateFlagBitsKHR bit1 )
- {
- return Win32SurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#ifdef VK_USE_PLATFORM_XLIB_KHR
#ifdef VK_USE_PLATFORM_XLIB_KHR
using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
-
- VULKAN_HPP_INLINE XlibSurfaceCreateFlagsKHR operator|( XlibSurfaceCreateFlagBitsKHR bit0, XlibSurfaceCreateFlagBitsKHR bit1 )
- {
- return XlibSurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#ifdef VK_USE_PLATFORM_XCB_KHR
#ifdef VK_USE_PLATFORM_XCB_KHR
using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
-
- VULKAN_HPP_INLINE XcbSurfaceCreateFlagsKHR operator|( XcbSurfaceCreateFlagBitsKHR bit0, XcbSurfaceCreateFlagBitsKHR bit1 )
- {
- return XcbSurfaceCreateFlagsKHR( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#ifdef VK_USE_PLATFORM_IOS_MVK
#ifdef VK_USE_PLATFORM_IOS_MVK
using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
-
- VULKAN_HPP_INLINE IOSSurfaceCreateFlagsMVK operator|( IOSSurfaceCreateFlagBitsMVK bit0, IOSSurfaceCreateFlagBitsMVK bit1 )
- {
- return IOSSurfaceCreateFlagsMVK( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#ifdef VK_USE_PLATFORM_MACOS_MVK
#ifdef VK_USE_PLATFORM_MACOS_MVK
using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
-
- VULKAN_HPP_INLINE MacOSSurfaceCreateFlagsMVK operator|( MacOSSurfaceCreateFlagBitsMVK bit0, MacOSSurfaceCreateFlagBitsMVK bit1 )
- {
- return MacOSSurfaceCreateFlagsMVK( bit0 ) | bit1;
- }
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
enum class CommandPoolTrimFlagBitsKHR
using CommandPoolTrimFlagsKHR = Flags<CommandPoolTrimFlagBitsKHR, VkCommandPoolTrimFlagsKHR>;
- VULKAN_HPP_INLINE CommandPoolTrimFlagsKHR operator|( CommandPoolTrimFlagBitsKHR bit0, CommandPoolTrimFlagBitsKHR bit1 )
- {
- return CommandPoolTrimFlagsKHR( bit0 ) | bit1;
- }
-
enum class PipelineViewportSwizzleStateCreateFlagBitsNV
{
};
using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>;
- VULKAN_HPP_INLINE PipelineViewportSwizzleStateCreateFlagsNV operator|( PipelineViewportSwizzleStateCreateFlagBitsNV bit0, PipelineViewportSwizzleStateCreateFlagBitsNV bit1 )
- {
- return PipelineViewportSwizzleStateCreateFlagsNV( bit0 ) | bit1;
- }
-
enum class PipelineDiscardRectangleStateCreateFlagBitsEXT
{
};
using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>;
- VULKAN_HPP_INLINE PipelineDiscardRectangleStateCreateFlagsEXT operator|( PipelineDiscardRectangleStateCreateFlagBitsEXT bit0, PipelineDiscardRectangleStateCreateFlagBitsEXT bit1 )
- {
- return PipelineDiscardRectangleStateCreateFlagsEXT( bit0 ) | bit1;
- }
-
class DeviceMemory
{
public:
: m_deviceMemory(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory)
- : m_deviceMemory(deviceMemory)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
+ : m_deviceMemory( deviceMemory )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DeviceMemory& operator=(VkDeviceMemory deviceMemory)
+ DeviceMemory & operator=(VkDeviceMemory deviceMemory)
{
m_deviceMemory = deviceMemory;
- return *this;
+ return *this;
}
#endif
- DeviceMemory& operator=( std::nullptr_t )
+ DeviceMemory & operator=( std::nullptr_t )
{
m_deviceMemory = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DeviceMemory const &rhs) const
+ bool operator==( DeviceMemory const & rhs ) const
{
return m_deviceMemory == rhs.m_deviceMemory;
}
- bool operator!=(DeviceMemory const &rhs) const
+ bool operator!=(DeviceMemory const & rhs ) const
{
return m_deviceMemory != rhs.m_deviceMemory;
}
- bool operator<(DeviceMemory const &rhs) const
+ bool operator<(DeviceMemory const & rhs ) const
{
return m_deviceMemory < rhs.m_deviceMemory;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const
{
return m_deviceMemory;
private:
VkDeviceMemory m_deviceMemory;
};
+
static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
class CommandPool
: m_commandPool(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool)
- : m_commandPool(commandPool)
+ VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
+ : m_commandPool( commandPool )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- CommandPool& operator=(VkCommandPool commandPool)
+ CommandPool & operator=(VkCommandPool commandPool)
{
m_commandPool = commandPool;
- return *this;
+ return *this;
}
#endif
- CommandPool& operator=( std::nullptr_t )
+ CommandPool & operator=( std::nullptr_t )
{
m_commandPool = VK_NULL_HANDLE;
return *this;
}
- bool operator==(CommandPool const &rhs) const
+ bool operator==( CommandPool const & rhs ) const
{
return m_commandPool == rhs.m_commandPool;
}
- bool operator!=(CommandPool const &rhs) const
+ bool operator!=(CommandPool const & rhs ) const
{
return m_commandPool != rhs.m_commandPool;
}
- bool operator<(CommandPool const &rhs) const
+ bool operator<(CommandPool const & rhs ) const
{
return m_commandPool < rhs.m_commandPool;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const
{
return m_commandPool;
private:
VkCommandPool m_commandPool;
};
+
static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
class Buffer
: m_buffer(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer)
- : m_buffer(buffer)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer )
+ : m_buffer( buffer )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Buffer& operator=(VkBuffer buffer)
+ Buffer & operator=(VkBuffer buffer)
{
m_buffer = buffer;
- return *this;
+ return *this;
}
#endif
- Buffer& operator=( std::nullptr_t )
+ Buffer & operator=( std::nullptr_t )
{
m_buffer = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Buffer const &rhs) const
+ bool operator==( Buffer const & rhs ) const
{
return m_buffer == rhs.m_buffer;
}
- bool operator!=(Buffer const &rhs) const
+ bool operator!=(Buffer const & rhs ) const
{
return m_buffer != rhs.m_buffer;
}
- bool operator<(Buffer const &rhs) const
+ bool operator<(Buffer const & rhs ) const
{
return m_buffer < rhs.m_buffer;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const
{
return m_buffer;
private:
VkBuffer m_buffer;
};
+
static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
class BufferView
: m_bufferView(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView)
- : m_bufferView(bufferView)
+ VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
+ : m_bufferView( bufferView )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- BufferView& operator=(VkBufferView bufferView)
+ BufferView & operator=(VkBufferView bufferView)
{
m_bufferView = bufferView;
- return *this;
+ return *this;
}
#endif
- BufferView& operator=( std::nullptr_t )
+ BufferView & operator=( std::nullptr_t )
{
m_bufferView = VK_NULL_HANDLE;
return *this;
}
- bool operator==(BufferView const &rhs) const
+ bool operator==( BufferView const & rhs ) const
{
return m_bufferView == rhs.m_bufferView;
}
- bool operator!=(BufferView const &rhs) const
+ bool operator!=(BufferView const & rhs ) const
{
return m_bufferView != rhs.m_bufferView;
}
- bool operator<(BufferView const &rhs) const
+ bool operator<(BufferView const & rhs ) const
{
return m_bufferView < rhs.m_bufferView;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const
{
return m_bufferView;
private:
VkBufferView m_bufferView;
};
+
static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
class Image
: m_image(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image)
- : m_image(image)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image )
+ : m_image( image )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Image& operator=(VkImage image)
+ Image & operator=(VkImage image)
{
m_image = image;
- return *this;
+ return *this;
}
#endif
- Image& operator=( std::nullptr_t )
+ Image & operator=( std::nullptr_t )
{
m_image = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Image const &rhs) const
+ bool operator==( Image const & rhs ) const
{
return m_image == rhs.m_image;
}
- bool operator!=(Image const &rhs) const
+ bool operator!=(Image const & rhs ) const
{
return m_image != rhs.m_image;
}
- bool operator<(Image const &rhs) const
+ bool operator<(Image const & rhs ) const
{
return m_image < rhs.m_image;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const
{
return m_image;
private:
VkImage m_image;
};
+
static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
class ImageView
: m_imageView(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView)
- : m_imageView(imageView)
+ VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView )
+ : m_imageView( imageView )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- ImageView& operator=(VkImageView imageView)
+ ImageView & operator=(VkImageView imageView)
{
m_imageView = imageView;
- return *this;
+ return *this;
}
#endif
- ImageView& operator=( std::nullptr_t )
+ ImageView & operator=( std::nullptr_t )
{
m_imageView = VK_NULL_HANDLE;
return *this;
}
- bool operator==(ImageView const &rhs) const
+ bool operator==( ImageView const & rhs ) const
{
return m_imageView == rhs.m_imageView;
}
- bool operator!=(ImageView const &rhs) const
+ bool operator!=(ImageView const & rhs ) const
{
return m_imageView != rhs.m_imageView;
}
- bool operator<(ImageView const &rhs) const
+ bool operator<(ImageView const & rhs ) const
{
return m_imageView < rhs.m_imageView;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const
{
return m_imageView;
private:
VkImageView m_imageView;
};
+
static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
class ShaderModule
: m_shaderModule(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule)
- : m_shaderModule(shaderModule)
+ VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
+ : m_shaderModule( shaderModule )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- ShaderModule& operator=(VkShaderModule shaderModule)
+ ShaderModule & operator=(VkShaderModule shaderModule)
{
m_shaderModule = shaderModule;
- return *this;
+ return *this;
}
#endif
- ShaderModule& operator=( std::nullptr_t )
+ ShaderModule & operator=( std::nullptr_t )
{
m_shaderModule = VK_NULL_HANDLE;
return *this;
}
- bool operator==(ShaderModule const &rhs) const
+ bool operator==( ShaderModule const & rhs ) const
{
return m_shaderModule == rhs.m_shaderModule;
}
- bool operator!=(ShaderModule const &rhs) const
+ bool operator!=(ShaderModule const & rhs ) const
{
return m_shaderModule != rhs.m_shaderModule;
}
- bool operator<(ShaderModule const &rhs) const
+ bool operator<(ShaderModule const & rhs ) const
{
return m_shaderModule < rhs.m_shaderModule;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const
{
return m_shaderModule;
private:
VkShaderModule m_shaderModule;
};
+
static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
class Pipeline
: m_pipeline(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline)
- : m_pipeline(pipeline)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline )
+ : m_pipeline( pipeline )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Pipeline& operator=(VkPipeline pipeline)
+ Pipeline & operator=(VkPipeline pipeline)
{
m_pipeline = pipeline;
- return *this;
+ return *this;
}
#endif
- Pipeline& operator=( std::nullptr_t )
+ Pipeline & operator=( std::nullptr_t )
{
m_pipeline = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Pipeline const &rhs) const
+ bool operator==( Pipeline const & rhs ) const
{
return m_pipeline == rhs.m_pipeline;
}
- bool operator!=(Pipeline const &rhs) const
+ bool operator!=(Pipeline const & rhs ) const
{
return m_pipeline != rhs.m_pipeline;
}
- bool operator<(Pipeline const &rhs) const
+ bool operator<(Pipeline const & rhs ) const
{
return m_pipeline < rhs.m_pipeline;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const
{
return m_pipeline;
private:
VkPipeline m_pipeline;
};
+
static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
class PipelineLayout
: m_pipelineLayout(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout)
- : m_pipelineLayout(pipelineLayout)
+ VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
+ : m_pipelineLayout( pipelineLayout )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- PipelineLayout& operator=(VkPipelineLayout pipelineLayout)
+ PipelineLayout & operator=(VkPipelineLayout pipelineLayout)
{
m_pipelineLayout = pipelineLayout;
- return *this;
+ return *this;
}
#endif
- PipelineLayout& operator=( std::nullptr_t )
+ PipelineLayout & operator=( std::nullptr_t )
{
m_pipelineLayout = VK_NULL_HANDLE;
return *this;
}
- bool operator==(PipelineLayout const &rhs) const
+ bool operator==( PipelineLayout const & rhs ) const
{
return m_pipelineLayout == rhs.m_pipelineLayout;
}
- bool operator!=(PipelineLayout const &rhs) const
+ bool operator!=(PipelineLayout const & rhs ) const
{
return m_pipelineLayout != rhs.m_pipelineLayout;
}
- bool operator<(PipelineLayout const &rhs) const
+ bool operator<(PipelineLayout const & rhs ) const
{
return m_pipelineLayout < rhs.m_pipelineLayout;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const
{
return m_pipelineLayout;
private:
VkPipelineLayout m_pipelineLayout;
};
+
static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
class Sampler
: m_sampler(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler)
- : m_sampler(sampler)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler )
+ : m_sampler( sampler )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Sampler& operator=(VkSampler sampler)
+ Sampler & operator=(VkSampler sampler)
{
m_sampler = sampler;
- return *this;
+ return *this;
}
#endif
- Sampler& operator=( std::nullptr_t )
+ Sampler & operator=( std::nullptr_t )
{
m_sampler = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Sampler const &rhs) const
+ bool operator==( Sampler const & rhs ) const
{
return m_sampler == rhs.m_sampler;
}
- bool operator!=(Sampler const &rhs) const
+ bool operator!=(Sampler const & rhs ) const
{
return m_sampler != rhs.m_sampler;
}
- bool operator<(Sampler const &rhs) const
+ bool operator<(Sampler const & rhs ) const
{
return m_sampler < rhs.m_sampler;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const
{
return m_sampler;
private:
VkSampler m_sampler;
};
+
static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
class DescriptorSet
: m_descriptorSet(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet)
- : m_descriptorSet(descriptorSet)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
+ : m_descriptorSet( descriptorSet )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DescriptorSet& operator=(VkDescriptorSet descriptorSet)
+ DescriptorSet & operator=(VkDescriptorSet descriptorSet)
{
m_descriptorSet = descriptorSet;
- return *this;
+ return *this;
}
#endif
- DescriptorSet& operator=( std::nullptr_t )
+ DescriptorSet & operator=( std::nullptr_t )
{
m_descriptorSet = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DescriptorSet const &rhs) const
+ bool operator==( DescriptorSet const & rhs ) const
{
return m_descriptorSet == rhs.m_descriptorSet;
}
- bool operator!=(DescriptorSet const &rhs) const
+ bool operator!=(DescriptorSet const & rhs ) const
{
return m_descriptorSet != rhs.m_descriptorSet;
}
- bool operator<(DescriptorSet const &rhs) const
+ bool operator<(DescriptorSet const & rhs ) const
{
return m_descriptorSet < rhs.m_descriptorSet;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const
{
return m_descriptorSet;
private:
VkDescriptorSet m_descriptorSet;
};
+
static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
class DescriptorSetLayout
: m_descriptorSetLayout(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)
- : m_descriptorSetLayout(descriptorSetLayout)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
+ : m_descriptorSetLayout( descriptorSetLayout )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DescriptorSetLayout& operator=(VkDescriptorSetLayout descriptorSetLayout)
+ DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout)
{
m_descriptorSetLayout = descriptorSetLayout;
- return *this;
+ return *this;
}
#endif
- DescriptorSetLayout& operator=( std::nullptr_t )
+ DescriptorSetLayout & operator=( std::nullptr_t )
{
m_descriptorSetLayout = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DescriptorSetLayout const &rhs) const
+ bool operator==( DescriptorSetLayout const & rhs ) const
{
return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
}
- bool operator!=(DescriptorSetLayout const &rhs) const
+ bool operator!=(DescriptorSetLayout const & rhs ) const
{
return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
}
- bool operator<(DescriptorSetLayout const &rhs) const
+ bool operator<(DescriptorSetLayout const & rhs ) const
{
return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const
{
return m_descriptorSetLayout;
private:
VkDescriptorSetLayout m_descriptorSetLayout;
};
+
static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
class DescriptorPool
: m_descriptorPool(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool)
- : m_descriptorPool(descriptorPool)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
+ : m_descriptorPool( descriptorPool )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DescriptorPool& operator=(VkDescriptorPool descriptorPool)
+ DescriptorPool & operator=(VkDescriptorPool descriptorPool)
{
m_descriptorPool = descriptorPool;
- return *this;
+ return *this;
}
#endif
- DescriptorPool& operator=( std::nullptr_t )
+ DescriptorPool & operator=( std::nullptr_t )
{
m_descriptorPool = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DescriptorPool const &rhs) const
+ bool operator==( DescriptorPool const & rhs ) const
{
return m_descriptorPool == rhs.m_descriptorPool;
}
- bool operator!=(DescriptorPool const &rhs) const
+ bool operator!=(DescriptorPool const & rhs ) const
{
return m_descriptorPool != rhs.m_descriptorPool;
}
- bool operator<(DescriptorPool const &rhs) const
+ bool operator<(DescriptorPool const & rhs ) const
{
return m_descriptorPool < rhs.m_descriptorPool;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const
{
return m_descriptorPool;
private:
VkDescriptorPool m_descriptorPool;
};
+
static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
class Fence
: m_fence(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence)
- : m_fence(fence)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence )
+ : m_fence( fence )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Fence& operator=(VkFence fence)
+ Fence & operator=(VkFence fence)
{
m_fence = fence;
- return *this;
+ return *this;
}
#endif
- Fence& operator=( std::nullptr_t )
+ Fence & operator=( std::nullptr_t )
{
m_fence = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Fence const &rhs) const
+ bool operator==( Fence const & rhs ) const
{
return m_fence == rhs.m_fence;
}
- bool operator!=(Fence const &rhs) const
+ bool operator!=(Fence const & rhs ) const
{
return m_fence != rhs.m_fence;
}
- bool operator<(Fence const &rhs) const
+ bool operator<(Fence const & rhs ) const
{
return m_fence < rhs.m_fence;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const
{
return m_fence;
private:
VkFence m_fence;
};
+
static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
class Semaphore
: m_semaphore(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore)
- : m_semaphore(semaphore)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore )
+ : m_semaphore( semaphore )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Semaphore& operator=(VkSemaphore semaphore)
+ Semaphore & operator=(VkSemaphore semaphore)
{
m_semaphore = semaphore;
- return *this;
+ return *this;
}
#endif
- Semaphore& operator=( std::nullptr_t )
+ Semaphore & operator=( std::nullptr_t )
{
m_semaphore = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Semaphore const &rhs) const
+ bool operator==( Semaphore const & rhs ) const
{
return m_semaphore == rhs.m_semaphore;
}
- bool operator!=(Semaphore const &rhs) const
+ bool operator!=(Semaphore const & rhs ) const
{
return m_semaphore != rhs.m_semaphore;
}
- bool operator<(Semaphore const &rhs) const
+ bool operator<(Semaphore const & rhs ) const
{
return m_semaphore < rhs.m_semaphore;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const
{
return m_semaphore;
private:
VkSemaphore m_semaphore;
};
+
static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
class Event
: m_event(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event)
- : m_event(event)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event )
+ : m_event( event )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Event& operator=(VkEvent event)
+ Event & operator=(VkEvent event)
{
m_event = event;
- return *this;
+ return *this;
}
#endif
- Event& operator=( std::nullptr_t )
+ Event & operator=( std::nullptr_t )
{
m_event = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Event const &rhs) const
+ bool operator==( Event const & rhs ) const
{
return m_event == rhs.m_event;
}
- bool operator!=(Event const &rhs) const
+ bool operator!=(Event const & rhs ) const
{
return m_event != rhs.m_event;
}
- bool operator<(Event const &rhs) const
+ bool operator<(Event const & rhs ) const
{
return m_event < rhs.m_event;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const
{
return m_event;
private:
VkEvent m_event;
};
+
static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
class QueryPool
: m_queryPool(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool)
- : m_queryPool(queryPool)
+ VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool )
+ : m_queryPool( queryPool )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- QueryPool& operator=(VkQueryPool queryPool)
+ QueryPool & operator=(VkQueryPool queryPool)
{
m_queryPool = queryPool;
- return *this;
+ return *this;
}
#endif
- QueryPool& operator=( std::nullptr_t )
+ QueryPool & operator=( std::nullptr_t )
{
m_queryPool = VK_NULL_HANDLE;
return *this;
}
- bool operator==(QueryPool const &rhs) const
+ bool operator==( QueryPool const & rhs ) const
{
return m_queryPool == rhs.m_queryPool;
}
- bool operator!=(QueryPool const &rhs) const
+ bool operator!=(QueryPool const & rhs ) const
{
return m_queryPool != rhs.m_queryPool;
}
- bool operator<(QueryPool const &rhs) const
+ bool operator<(QueryPool const & rhs ) const
{
return m_queryPool < rhs.m_queryPool;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const
{
return m_queryPool;
private:
VkQueryPool m_queryPool;
};
+
static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
class Framebuffer
: m_framebuffer(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer)
- : m_framebuffer(framebuffer)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer )
+ : m_framebuffer( framebuffer )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Framebuffer& operator=(VkFramebuffer framebuffer)
+ Framebuffer & operator=(VkFramebuffer framebuffer)
{
m_framebuffer = framebuffer;
- return *this;
+ return *this;
}
#endif
- Framebuffer& operator=( std::nullptr_t )
+ Framebuffer & operator=( std::nullptr_t )
{
m_framebuffer = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Framebuffer const &rhs) const
+ bool operator==( Framebuffer const & rhs ) const
{
return m_framebuffer == rhs.m_framebuffer;
}
- bool operator!=(Framebuffer const &rhs) const
+ bool operator!=(Framebuffer const & rhs ) const
{
return m_framebuffer != rhs.m_framebuffer;
}
- bool operator<(Framebuffer const &rhs) const
+ bool operator<(Framebuffer const & rhs ) const
{
return m_framebuffer < rhs.m_framebuffer;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const
{
return m_framebuffer;
private:
VkFramebuffer m_framebuffer;
};
+
static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
class RenderPass
: m_renderPass(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass)
- : m_renderPass(renderPass)
+ VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
+ : m_renderPass( renderPass )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- RenderPass& operator=(VkRenderPass renderPass)
+ RenderPass & operator=(VkRenderPass renderPass)
{
m_renderPass = renderPass;
- return *this;
+ return *this;
}
#endif
- RenderPass& operator=( std::nullptr_t )
+ RenderPass & operator=( std::nullptr_t )
{
m_renderPass = VK_NULL_HANDLE;
return *this;
}
- bool operator==(RenderPass const &rhs) const
+ bool operator==( RenderPass const & rhs ) const
{
return m_renderPass == rhs.m_renderPass;
}
- bool operator!=(RenderPass const &rhs) const
+ bool operator!=(RenderPass const & rhs ) const
{
return m_renderPass != rhs.m_renderPass;
}
- bool operator<(RenderPass const &rhs) const
+ bool operator<(RenderPass const & rhs ) const
{
return m_renderPass < rhs.m_renderPass;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const
{
return m_renderPass;
private:
VkRenderPass m_renderPass;
};
+
static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
class PipelineCache
: m_pipelineCache(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache)
- : m_pipelineCache(pipelineCache)
+ VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
+ : m_pipelineCache( pipelineCache )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- PipelineCache& operator=(VkPipelineCache pipelineCache)
+ PipelineCache & operator=(VkPipelineCache pipelineCache)
{
m_pipelineCache = pipelineCache;
- return *this;
+ return *this;
}
#endif
- PipelineCache& operator=( std::nullptr_t )
+ PipelineCache & operator=( std::nullptr_t )
{
m_pipelineCache = VK_NULL_HANDLE;
return *this;
}
- bool operator==(PipelineCache const &rhs) const
+ bool operator==( PipelineCache const & rhs ) const
{
return m_pipelineCache == rhs.m_pipelineCache;
}
- bool operator!=(PipelineCache const &rhs) const
+ bool operator!=(PipelineCache const & rhs ) const
{
return m_pipelineCache != rhs.m_pipelineCache;
}
- bool operator<(PipelineCache const &rhs) const
+ bool operator<(PipelineCache const & rhs ) const
{
return m_pipelineCache < rhs.m_pipelineCache;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const
{
return m_pipelineCache;
private:
VkPipelineCache m_pipelineCache;
};
+
static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
class ObjectTableNVX
: m_objectTableNVX(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX(VkObjectTableNVX objectTableNVX)
- : m_objectTableNVX(objectTableNVX)
+ VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
+ : m_objectTableNVX( objectTableNVX )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- ObjectTableNVX& operator=(VkObjectTableNVX objectTableNVX)
+ ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX)
{
m_objectTableNVX = objectTableNVX;
- return *this;
+ return *this;
}
#endif
- ObjectTableNVX& operator=( std::nullptr_t )
+ ObjectTableNVX & operator=( std::nullptr_t )
{
m_objectTableNVX = VK_NULL_HANDLE;
return *this;
}
- bool operator==(ObjectTableNVX const &rhs) const
+ bool operator==( ObjectTableNVX const & rhs ) const
{
return m_objectTableNVX == rhs.m_objectTableNVX;
}
- bool operator!=(ObjectTableNVX const &rhs) const
+ bool operator!=(ObjectTableNVX const & rhs ) const
{
return m_objectTableNVX != rhs.m_objectTableNVX;
}
- bool operator<(ObjectTableNVX const &rhs) const
+ bool operator<(ObjectTableNVX const & rhs ) const
{
return m_objectTableNVX < rhs.m_objectTableNVX;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const
{
return m_objectTableNVX;
private:
VkObjectTableNVX m_objectTableNVX;
};
+
static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
class IndirectCommandsLayoutNVX
: m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
- : m_indirectCommandsLayoutNVX(indirectCommandsLayoutNVX)
+ VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
+ : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- IndirectCommandsLayoutNVX& operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
+ IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
{
m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX;
- return *this;
+ return *this;
}
#endif
- IndirectCommandsLayoutNVX& operator=( std::nullptr_t )
+ IndirectCommandsLayoutNVX & operator=( std::nullptr_t )
{
m_indirectCommandsLayoutNVX = VK_NULL_HANDLE;
return *this;
}
- bool operator==(IndirectCommandsLayoutNVX const &rhs) const
+ bool operator==( IndirectCommandsLayoutNVX const & rhs ) const
{
return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX;
}
- bool operator!=(IndirectCommandsLayoutNVX const &rhs) const
+ bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const
{
return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX;
}
- bool operator<(IndirectCommandsLayoutNVX const &rhs) const
+ bool operator<(IndirectCommandsLayoutNVX const & rhs ) const
{
return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const
{
return m_indirectCommandsLayoutNVX;
private:
VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX;
};
+
static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
class DescriptorUpdateTemplateKHR
: m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR)
- : m_descriptorUpdateTemplateKHR(descriptorUpdateTemplateKHR)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
+ : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DescriptorUpdateTemplateKHR& operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR)
+ DescriptorUpdateTemplateKHR & operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR)
{
m_descriptorUpdateTemplateKHR = descriptorUpdateTemplateKHR;
- return *this;
+ return *this;
}
#endif
- DescriptorUpdateTemplateKHR& operator=( std::nullptr_t )
+ DescriptorUpdateTemplateKHR & operator=( std::nullptr_t )
{
m_descriptorUpdateTemplateKHR = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DescriptorUpdateTemplateKHR const &rhs) const
+ bool operator==( DescriptorUpdateTemplateKHR const & rhs ) const
{
return m_descriptorUpdateTemplateKHR == rhs.m_descriptorUpdateTemplateKHR;
}
- bool operator!=(DescriptorUpdateTemplateKHR const &rhs) const
+ bool operator!=(DescriptorUpdateTemplateKHR const & rhs ) const
{
return m_descriptorUpdateTemplateKHR != rhs.m_descriptorUpdateTemplateKHR;
}
- bool operator<(DescriptorUpdateTemplateKHR const &rhs) const
+ bool operator<(DescriptorUpdateTemplateKHR const & rhs ) const
{
return m_descriptorUpdateTemplateKHR < rhs.m_descriptorUpdateTemplateKHR;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplateKHR() const
{
return m_descriptorUpdateTemplateKHR;
private:
VkDescriptorUpdateTemplateKHR m_descriptorUpdateTemplateKHR;
};
+
static_assert( sizeof( DescriptorUpdateTemplateKHR ) == sizeof( VkDescriptorUpdateTemplateKHR ), "handle and wrapper have different size!" );
class DisplayKHR
: m_displayKHR(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR)
- : m_displayKHR(displayKHR)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
+ : m_displayKHR( displayKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DisplayKHR& operator=(VkDisplayKHR displayKHR)
+ DisplayKHR & operator=(VkDisplayKHR displayKHR)
{
m_displayKHR = displayKHR;
- return *this;
+ return *this;
}
#endif
- DisplayKHR& operator=( std::nullptr_t )
+ DisplayKHR & operator=( std::nullptr_t )
{
m_displayKHR = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DisplayKHR const &rhs) const
+ bool operator==( DisplayKHR const & rhs ) const
{
return m_displayKHR == rhs.m_displayKHR;
}
- bool operator!=(DisplayKHR const &rhs) const
+ bool operator!=(DisplayKHR const & rhs ) const
{
return m_displayKHR != rhs.m_displayKHR;
}
- bool operator<(DisplayKHR const &rhs) const
+ bool operator<(DisplayKHR const & rhs ) const
{
return m_displayKHR < rhs.m_displayKHR;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const
{
return m_displayKHR;
private:
VkDisplayKHR m_displayKHR;
};
+
static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
class DisplayModeKHR
: m_displayModeKHR(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR)
- : m_displayModeKHR(displayModeKHR)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
+ : m_displayModeKHR( displayModeKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DisplayModeKHR& operator=(VkDisplayModeKHR displayModeKHR)
+ DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR)
{
m_displayModeKHR = displayModeKHR;
- return *this;
+ return *this;
}
#endif
- DisplayModeKHR& operator=( std::nullptr_t )
+ DisplayModeKHR & operator=( std::nullptr_t )
{
m_displayModeKHR = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DisplayModeKHR const &rhs) const
+ bool operator==( DisplayModeKHR const & rhs ) const
{
return m_displayModeKHR == rhs.m_displayModeKHR;
}
- bool operator!=(DisplayModeKHR const &rhs) const
+ bool operator!=(DisplayModeKHR const & rhs ) const
{
return m_displayModeKHR != rhs.m_displayModeKHR;
}
- bool operator<(DisplayModeKHR const &rhs) const
+ bool operator<(DisplayModeKHR const & rhs ) const
{
return m_displayModeKHR < rhs.m_displayModeKHR;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const
{
return m_displayModeKHR;
private:
VkDisplayModeKHR m_displayModeKHR;
};
+
static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
class SurfaceKHR
: m_surfaceKHR(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR)
- : m_surfaceKHR(surfaceKHR)
+ VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
+ : m_surfaceKHR( surfaceKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- SurfaceKHR& operator=(VkSurfaceKHR surfaceKHR)
+ SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR)
{
m_surfaceKHR = surfaceKHR;
- return *this;
+ return *this;
}
#endif
- SurfaceKHR& operator=( std::nullptr_t )
+ SurfaceKHR & operator=( std::nullptr_t )
{
m_surfaceKHR = VK_NULL_HANDLE;
return *this;
}
- bool operator==(SurfaceKHR const &rhs) const
+ bool operator==( SurfaceKHR const & rhs ) const
{
return m_surfaceKHR == rhs.m_surfaceKHR;
}
- bool operator!=(SurfaceKHR const &rhs) const
+ bool operator!=(SurfaceKHR const & rhs ) const
{
return m_surfaceKHR != rhs.m_surfaceKHR;
}
- bool operator<(SurfaceKHR const &rhs) const
+ bool operator<(SurfaceKHR const & rhs ) const
{
return m_surfaceKHR < rhs.m_surfaceKHR;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const
{
return m_surfaceKHR;
private:
VkSurfaceKHR m_surfaceKHR;
};
+
static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
class SwapchainKHR
: m_swapchainKHR(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR)
- : m_swapchainKHR(swapchainKHR)
+ VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
+ : m_swapchainKHR( swapchainKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- SwapchainKHR& operator=(VkSwapchainKHR swapchainKHR)
+ SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR)
{
m_swapchainKHR = swapchainKHR;
- return *this;
+ return *this;
}
#endif
- SwapchainKHR& operator=( std::nullptr_t )
+ SwapchainKHR & operator=( std::nullptr_t )
{
m_swapchainKHR = VK_NULL_HANDLE;
return *this;
}
- bool operator==(SwapchainKHR const &rhs) const
+ bool operator==( SwapchainKHR const & rhs ) const
{
return m_swapchainKHR == rhs.m_swapchainKHR;
}
- bool operator!=(SwapchainKHR const &rhs) const
+ bool operator!=(SwapchainKHR const & rhs ) const
{
return m_swapchainKHR != rhs.m_swapchainKHR;
}
- bool operator<(SwapchainKHR const &rhs) const
+ bool operator<(SwapchainKHR const & rhs ) const
{
return m_swapchainKHR < rhs.m_swapchainKHR;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const
{
return m_swapchainKHR;
private:
VkSwapchainKHR m_swapchainKHR;
};
+
static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
class DebugReportCallbackEXT
: m_debugReportCallbackEXT(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)
- : m_debugReportCallbackEXT(debugReportCallbackEXT)
+ VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
+ : m_debugReportCallbackEXT( debugReportCallbackEXT )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- DebugReportCallbackEXT& operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
+ DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
{
m_debugReportCallbackEXT = debugReportCallbackEXT;
- return *this;
+ return *this;
}
#endif
- DebugReportCallbackEXT& operator=( std::nullptr_t )
+ DebugReportCallbackEXT & operator=( std::nullptr_t )
{
m_debugReportCallbackEXT = VK_NULL_HANDLE;
return *this;
}
- bool operator==(DebugReportCallbackEXT const &rhs) const
+ bool operator==( DebugReportCallbackEXT const & rhs ) const
{
return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
}
- bool operator!=(DebugReportCallbackEXT const &rhs) const
+ bool operator!=(DebugReportCallbackEXT const & rhs ) const
{
return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
}
- bool operator<(DebugReportCallbackEXT const &rhs) const
+ bool operator<(DebugReportCallbackEXT const & rhs ) const
{
return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
}
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const
{
return m_debugReportCallbackEXT;
private:
VkDebugReportCallbackEXT m_debugReportCallbackEXT;
};
+
static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
struct Offset2D
Offset2D( VkOffset2D const & rhs )
{
- memcpy( this, &rhs, sizeof(Offset2D) );
+ memcpy( this, &rhs, sizeof( Offset2D ) );
}
Offset2D& operator=( VkOffset2D const & rhs )
{
- memcpy( this, &rhs, sizeof(Offset2D) );
+ memcpy( this, &rhs, sizeof( Offset2D ) );
return *this;
}
-
Offset2D& setX( int32_t x_ )
{
x = x_;
Offset3D( VkOffset3D const & rhs )
{
- memcpy( this, &rhs, sizeof(Offset3D) );
+ memcpy( this, &rhs, sizeof( Offset3D ) );
}
Offset3D& operator=( VkOffset3D const & rhs )
{
- memcpy( this, &rhs, sizeof(Offset3D) );
+ memcpy( this, &rhs, sizeof( Offset3D ) );
return *this;
}
-
Offset3D& setX( int32_t x_ )
{
x = x_;
Extent2D( VkExtent2D const & rhs )
{
- memcpy( this, &rhs, sizeof(Extent2D) );
+ memcpy( this, &rhs, sizeof( Extent2D ) );
}
Extent2D& operator=( VkExtent2D const & rhs )
{
- memcpy( this, &rhs, sizeof(Extent2D) );
+ memcpy( this, &rhs, sizeof( Extent2D ) );
return *this;
}
-
Extent2D& setWidth( uint32_t width_ )
{
width = width_;
Extent3D( VkExtent3D const & rhs )
{
- memcpy( this, &rhs, sizeof(Extent3D) );
+ memcpy( this, &rhs, sizeof( Extent3D ) );
}
Extent3D& operator=( VkExtent3D const & rhs )
{
- memcpy( this, &rhs, sizeof(Extent3D) );
+ memcpy( this, &rhs, sizeof( Extent3D ) );
return *this;
}
-
Extent3D& setWidth( uint32_t width_ )
{
width = width_;
Viewport( VkViewport const & rhs )
{
- memcpy( this, &rhs, sizeof(Viewport) );
+ memcpy( this, &rhs, sizeof( Viewport ) );
}
Viewport& operator=( VkViewport const & rhs )
{
- memcpy( this, &rhs, sizeof(Viewport) );
+ memcpy( this, &rhs, sizeof( Viewport ) );
return *this;
}
-
Viewport& setX( float x_ )
{
x = x_;
Rect2D( VkRect2D const & rhs )
{
- memcpy( this, &rhs, sizeof(Rect2D) );
+ memcpy( this, &rhs, sizeof( Rect2D ) );
}
Rect2D& operator=( VkRect2D const & rhs )
{
- memcpy( this, &rhs, sizeof(Rect2D) );
+ memcpy( this, &rhs, sizeof( Rect2D ) );
return *this;
}
-
Rect2D& setOffset( Offset2D offset_ )
{
offset = offset_;
ClearRect( VkClearRect const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearRect) );
+ memcpy( this, &rhs, sizeof( ClearRect ) );
}
ClearRect& operator=( VkClearRect const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearRect) );
+ memcpy( this, &rhs, sizeof( ClearRect ) );
return *this;
}
-
ClearRect& setRect( Rect2D rect_ )
{
rect = rect_;
AllocationCallbacks( VkAllocationCallbacks const & rhs )
{
- memcpy( this, &rhs, sizeof(AllocationCallbacks) );
+ memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
}
AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
{
- memcpy( this, &rhs, sizeof(AllocationCallbacks) );
+ memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
return *this;
}
-
AllocationCallbacks& setPUserData( void* pUserData_ )
{
pUserData = pUserData_;
DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorBufferInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
}
DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorBufferInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
return *this;
}
-
DescriptorBufferInfo& setBuffer( Buffer buffer_ )
{
buffer = buffer_;
BufferCopy( VkBufferCopy const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferCopy) );
+ memcpy( this, &rhs, sizeof( BufferCopy ) );
}
BufferCopy& operator=( VkBufferCopy const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferCopy) );
+ memcpy( this, &rhs, sizeof( BufferCopy ) );
return *this;
}
-
BufferCopy& setSrcOffset( DeviceSize srcOffset_ )
{
srcOffset = srcOffset_;
SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
{
- memcpy( this, &rhs, sizeof(SpecializationMapEntry) );
+ memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
}
SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
{
- memcpy( this, &rhs, sizeof(SpecializationMapEntry) );
+ memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
return *this;
}
-
SpecializationMapEntry& setConstantID( uint32_t constantID_ )
{
constantID = constantID_;
SpecializationInfo( VkSpecializationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SpecializationInfo) );
+ memcpy( this, &rhs, sizeof( SpecializationInfo ) );
}
SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SpecializationInfo) );
+ memcpy( this, &rhs, sizeof( SpecializationInfo ) );
return *this;
}
-
SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ )
{
mapEntryCount = mapEntryCount_;
ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearDepthStencilValue) );
+ memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
}
ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearDepthStencilValue) );
+ memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
return *this;
}
-
ClearDepthStencilValue& setDepth( float depth_ )
{
depth = depth_;
PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
}
PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
return *this;
}
-
PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ )
{
robustBufferAccess = robustBufferAccess_;
DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof(DrawIndirectCommand) );
+ memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
}
DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof(DrawIndirectCommand) );
+ memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
return *this;
}
-
DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ )
{
vertexCount = vertexCount_;
DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) );
+ memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
}
DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) );
+ memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
return *this;
}
-
DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ )
{
indexCount = indexCount_;
DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof(DispatchIndirectCommand) );
+ memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
}
DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
{
- memcpy( this, &rhs, sizeof(DispatchIndirectCommand) );
+ memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
return *this;
}
-
DispatchIndirectCommand& setX( uint32_t x_ )
{
x = x_;
DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) );
+ memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
}
DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) );
+ memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
return *this;
}
-
DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ )
{
visibleRegion = visibleRegion_;
RectLayerKHR( VkRectLayerKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(RectLayerKHR) );
+ memcpy( this, &rhs, sizeof( RectLayerKHR ) );
}
RectLayerKHR& operator=( VkRectLayerKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(RectLayerKHR) );
+ memcpy( this, &rhs, sizeof( RectLayerKHR ) );
return *this;
}
-
RectLayerKHR& setOffset( Offset2D offset_ )
{
offset = offset_;
PresentRegionKHR( VkPresentRegionKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentRegionKHR) );
+ memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
}
PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentRegionKHR) );
+ memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
return *this;
}
-
PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ )
{
rectangleCount = rectangleCount_;
XYColorEXT( VkXYColorEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(XYColorEXT) );
+ memcpy( this, &rhs, sizeof( XYColorEXT ) );
}
XYColorEXT& operator=( VkXYColorEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(XYColorEXT) );
+ memcpy( this, &rhs, sizeof( XYColorEXT ) );
return *this;
}
-
XYColorEXT& setX( float x_ )
{
x = x_;
RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(RefreshCycleDurationGOOGLE) );
+ memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) );
}
RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(RefreshCycleDurationGOOGLE) );
+ memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) );
return *this;
}
-
RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ )
{
refreshDuration = refreshDuration_;
PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(PastPresentationTimingGOOGLE) );
+ memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) );
}
PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(PastPresentationTimingGOOGLE) );
+ memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) );
return *this;
}
-
PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ )
{
presentID = presentID_;
PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentTimeGOOGLE) );
+ memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
}
PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentTimeGOOGLE) );
+ memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
return *this;
}
-
PresentTimeGOOGLE& setPresentID( uint32_t presentID_ )
{
presentID = presentID_;
ViewportWScalingNV( VkViewportWScalingNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ViewportWScalingNV) );
+ memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
}
ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ViewportWScalingNV) );
+ memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
return *this;
}
-
ViewportWScalingNV& setXcoeff( float xcoeff_ )
{
xcoeff = xcoeff_;
DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorImageInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
}
DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorImageInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
return *this;
}
-
DescriptorImageInfo& setSampler( Sampler sampler_ )
{
sampler = sampler_;
AttachmentReference( VkAttachmentReference const & rhs )
{
- memcpy( this, &rhs, sizeof(AttachmentReference) );
+ memcpy( this, &rhs, sizeof( AttachmentReference ) );
}
AttachmentReference& operator=( VkAttachmentReference const & rhs )
{
- memcpy( this, &rhs, sizeof(AttachmentReference) );
+ memcpy( this, &rhs, sizeof( AttachmentReference ) );
return *this;
}
-
AttachmentReference& setAttachment( uint32_t attachment_ )
{
attachment = attachment_;
ComponentMapping( VkComponentMapping const & rhs )
{
- memcpy( this, &rhs, sizeof(ComponentMapping) );
+ memcpy( this, &rhs, sizeof( ComponentMapping ) );
}
ComponentMapping& operator=( VkComponentMapping const & rhs )
{
- memcpy( this, &rhs, sizeof(ComponentMapping) );
+ memcpy( this, &rhs, sizeof( ComponentMapping ) );
return *this;
}
-
ComponentMapping& setR( ComponentSwizzle r_ )
{
r = r_;
DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorPoolSize) );
+ memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
}
DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorPoolSize) );
+ memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
return *this;
}
-
DescriptorPoolSize& setType( DescriptorType type_ )
{
type = type_;
DescriptorUpdateTemplateEntryKHR( VkDescriptorUpdateTemplateEntryKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) );
+ memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) );
}
DescriptorUpdateTemplateEntryKHR& operator=( VkDescriptorUpdateTemplateEntryKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) );
+ memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) );
return *this;
}
-
DescriptorUpdateTemplateEntryKHR& setDstBinding( uint32_t dstBinding_ )
{
dstBinding = dstBinding_;
StencilOpState( VkStencilOpState const & rhs )
{
- memcpy( this, &rhs, sizeof(StencilOpState) );
+ memcpy( this, &rhs, sizeof( StencilOpState ) );
}
StencilOpState& operator=( VkStencilOpState const & rhs )
{
- memcpy( this, &rhs, sizeof(StencilOpState) );
+ memcpy( this, &rhs, sizeof( StencilOpState ) );
return *this;
}
-
StencilOpState& setFailOp( StencilOp failOp_ )
{
failOp = failOp_;
VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(VertexInputBindingDescription) );
+ memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
}
VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(VertexInputBindingDescription) );
+ memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
return *this;
}
-
VertexInputBindingDescription& setBinding( uint32_t binding_ )
{
binding = binding_;
VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) );
+ memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
}
VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) );
+ memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
return *this;
}
-
VertexInputAttributeDescription& setLocation( uint32_t location_ )
{
location = location_;
eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
+ eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
eRenderPassMultiviewCreateInfoKHX = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX,
ePhysicalDeviceMultiviewFeaturesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX,
ePhysicalDeviceMultiviewPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX,
ApplicationInfo( VkApplicationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ApplicationInfo) );
+ memcpy( this, &rhs, sizeof( ApplicationInfo ) );
}
ApplicationInfo& operator=( VkApplicationInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ApplicationInfo) );
+ memcpy( this, &rhs, sizeof( ApplicationInfo ) );
return *this;
}
-
ApplicationInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) );
+ memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
}
DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) );
+ memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
return *this;
}
-
DeviceQueueCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceCreateInfo) );
+ memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
}
DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceCreateInfo) );
+ memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
return *this;
}
-
DeviceCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(InstanceCreateInfo) );
+ memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
}
InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(InstanceCreateInfo) );
+ memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
return *this;
}
-
InstanceCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(MemoryAllocateInfo) );
+ memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
}
MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(MemoryAllocateInfo) );
+ memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
return *this;
}
-
MemoryAllocateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
MappedMemoryRange( VkMappedMemoryRange const & rhs )
{
- memcpy( this, &rhs, sizeof(MappedMemoryRange) );
+ memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
}
MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
{
- memcpy( this, &rhs, sizeof(MappedMemoryRange) );
+ memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
return *this;
}
-
MappedMemoryRange& setPNext( const void* pNext_ )
{
pNext = pNext_;
WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
{
- memcpy( this, &rhs, sizeof(WriteDescriptorSet) );
+ memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
}
WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
{
- memcpy( this, &rhs, sizeof(WriteDescriptorSet) );
+ memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
return *this;
}
-
WriteDescriptorSet& setPNext( const void* pNext_ )
{
pNext = pNext_;
CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
{
- memcpy( this, &rhs, sizeof(CopyDescriptorSet) );
+ memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
}
CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
{
- memcpy( this, &rhs, sizeof(CopyDescriptorSet) );
+ memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
return *this;
}
-
CopyDescriptorSet& setPNext( const void* pNext_ )
{
pNext = pNext_;
BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferViewCreateInfo) );
+ memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
}
BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferViewCreateInfo) );
+ memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
return *this;
}
-
BufferViewCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) );
+ memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
}
ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) );
+ memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
return *this;
}
-
ShaderModuleCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
}
DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
return *this;
}
-
DescriptorSetAllocateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
}
PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
return *this;
}
-
PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
}
PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
return *this;
}
-
PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
}
PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
return *this;
}
-
PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
}
PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
return *this;
}
-
PipelineViewportStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
}
PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
return *this;
}
-
PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
}
PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
return *this;
}
-
PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
}
PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
return *this;
}
-
PipelineCacheCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SamplerCreateInfo) );
+ memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
}
SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SamplerCreateInfo) );
+ memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
return *this;
}
-
SamplerCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) );
+ memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
}
CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) );
+ memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
return *this;
}
-
CommandBufferAllocateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassBeginInfo) );
+ memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
}
RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassBeginInfo) );
+ memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
return *this;
}
-
RenderPassBeginInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
EventCreateInfo( VkEventCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(EventCreateInfo) );
+ memcpy( this, &rhs, sizeof( EventCreateInfo ) );
}
EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(EventCreateInfo) );
+ memcpy( this, &rhs, sizeof( EventCreateInfo ) );
return *this;
}
-
EventCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) );
+ memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
}
SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) );
+ memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
return *this;
}
-
SemaphoreCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(FramebufferCreateInfo) );
+ memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
}
FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(FramebufferCreateInfo) );
+ memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
return *this;
}
-
FramebufferCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
}
DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
return *this;
}
-
DisplayModeCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) );
+ memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
}
DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) );
+ memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
return *this;
}
-
DisplayPresentInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
}
AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
return *this;
}
-
AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) );
}
MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) );
return *this;
}
-
MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
{
- memcpy( this, &rhs, sizeof(ViSurfaceCreateInfoNN) );
+ memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
}
ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
{
- memcpy( this, &rhs, sizeof(ViSurfaceCreateInfoNN) );
+ memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
return *this;
}
-
ViSurfaceCreateInfoNN& setPNext( const void* pNext_ )
{
pNext = pNext_;
WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
}
WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
return *this;
}
-
WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
}
Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
return *this;
}
-
Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
}
XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
return *this;
}
-
XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
}
XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
return *this;
}
-
XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
}
DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
return *this;
}
-
DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
}
DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
return *this;
}
-
DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
}
DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
return *this;
}
-
DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) );
+ memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
}
DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) );
+ memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
return *this;
}
-
DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) );
+ memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
}
ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) );
+ memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
return *this;
}
-
ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) );
+ memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
}
Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) );
+ memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
return *this;
}
-
Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsFeaturesNVX) );
+ memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
}
DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsFeaturesNVX) );
+ memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
return *this;
}
-
DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsLimitsNVX) );
+ memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
}
DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsLimitsNVX) );
+ memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
return *this;
}
-
DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(CmdReserveSpaceForCommandsInfoNVX) );
+ memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
}
CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(CmdReserveSpaceForCommandsInfoNVX) );
+ memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
return *this;
}
-
CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceFeatures2KHR( VkPhysicalDeviceFeatures2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) );
}
PhysicalDeviceFeatures2KHR& operator=( VkPhysicalDeviceFeatures2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) );
return *this;
}
-
PhysicalDeviceFeatures2KHR& setPNext( void* pNext_ )
{
pNext = pNext_;
PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
}
PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
return *this;
}
-
PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ )
{
pNext = pNext_;
PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentRegionsKHR) );
+ memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
}
PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentRegionsKHR) );
+ memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
return *this;
}
-
PresentRegionsKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExportMemoryWin32HandleInfoKHX( VkExportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHX ) );
}
ExportMemoryWin32HandleInfoKHX& operator=( VkExportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHX ) );
return *this;
}
-
ExportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
Win32KeyedMutexAcquireReleaseInfoKHX( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) );
+ memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) );
}
Win32KeyedMutexAcquireReleaseInfoKHX& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) );
+ memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) );
return *this;
}
-
Win32KeyedMutexAcquireReleaseInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExportSemaphoreWin32HandleInfoKHX( VkExportSemaphoreWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHX ) );
}
ExportSemaphoreWin32HandleInfoKHX& operator=( VkExportSemaphoreWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHX ) );
return *this;
}
-
ExportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
D3D12FenceSubmitInfoKHX( VkD3D12FenceSubmitInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) );
+ memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHX ) );
}
D3D12FenceSubmitInfoKHX& operator=( VkD3D12FenceSubmitInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) );
+ memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHX ) );
return *this;
}
-
D3D12FenceSubmitInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceMultiviewFeaturesKHX( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) );
}
PhysicalDeviceMultiviewFeaturesKHX& operator=( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) );
return *this;
}
-
PhysicalDeviceMultiviewFeaturesKHX& setPNext( void* pNext_ )
{
pNext = pNext_;
RenderPassMultiviewCreateInfoKHX( VkRenderPassMultiviewCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) );
}
RenderPassMultiviewCreateInfoKHX& operator=( VkRenderPassMultiviewCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) );
return *this;
}
-
RenderPassMultiviewCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
BindBufferMemoryInfoKHX( VkBindBufferMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) );
+ memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHX ) );
}
BindBufferMemoryInfoKHX& operator=( VkBindBufferMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) );
+ memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHX ) );
return *this;
}
-
BindBufferMemoryInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
BindImageMemoryInfoKHX( VkBindImageMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) );
+ memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHX ) );
}
BindImageMemoryInfoKHX& operator=( VkBindImageMemoryInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) );
+ memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHX ) );
return *this;
}
-
BindImageMemoryInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGroupRenderPassBeginInfoKHX( VkDeviceGroupRenderPassBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) );
}
DeviceGroupRenderPassBeginInfoKHX& operator=( VkDeviceGroupRenderPassBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) );
return *this;
}
-
DeviceGroupRenderPassBeginInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGroupCommandBufferBeginInfoKHX( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) );
}
DeviceGroupCommandBufferBeginInfoKHX& operator=( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) );
return *this;
}
-
DeviceGroupCommandBufferBeginInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGroupSubmitInfoKHX( VkDeviceGroupSubmitInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) );
}
DeviceGroupSubmitInfoKHX& operator=( VkDeviceGroupSubmitInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) );
return *this;
}
-
DeviceGroupSubmitInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGroupBindSparseInfoKHX( VkDeviceGroupBindSparseInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) );
}
DeviceGroupBindSparseInfoKHX& operator=( VkDeviceGroupBindSparseInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) );
return *this;
}
-
DeviceGroupBindSparseInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImageSwapchainCreateInfoKHX( VkImageSwapchainCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) );
}
ImageSwapchainCreateInfoKHX& operator=( VkImageSwapchainCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) );
return *this;
}
-
ImageSwapchainCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
BindImageMemorySwapchainInfoKHX( VkBindImageMemorySwapchainInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) );
+ memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) );
}
BindImageMemorySwapchainInfoKHX& operator=( VkBindImageMemorySwapchainInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) );
+ memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) );
return *this;
}
-
BindImageMemorySwapchainInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
AcquireNextImageInfoKHX( VkAcquireNextImageInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) );
+ memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) );
}
AcquireNextImageInfoKHX& operator=( VkAcquireNextImageInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) );
+ memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) );
return *this;
}
-
AcquireNextImageInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(HdrMetadataEXT) );
+ memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
}
HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(HdrMetadataEXT) );
+ memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
return *this;
}
-
HdrMetadataEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentTimesInfoGOOGLE) );
+ memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
}
PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentTimesInfoGOOGLE) );
+ memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
return *this;
}
-
PresentTimesInfoGOOGLE& setPNext( const void* pNext_ )
{
pNext = pNext_;
IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) );
+ memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
}
IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) );
+ memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
return *this;
}
-
IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
{
pNext = pNext_;
MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) );
+ memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
}
MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
{
- memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) );
+ memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
return *this;
}
-
MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
}
PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
return *this;
}
-
PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
}
PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
return *this;
}
-
PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceSurfaceInfo2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
}
PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceSurfaceInfo2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
return *this;
}
-
PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
};
static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
+ struct TextureLODGatherFormatPropertiesAMD
+ {
+ operator const VkTextureLODGatherFormatPropertiesAMD&() const
+ {
+ return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
+ }
+
+ bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
+ }
+
+ bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType;
+
+ public:
+ void* pNext;
+ Bool32 supportsTextureGatherLODBiasAMD;
+ };
+ static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
+
enum class SubpassContents
{
eInline = VK_SUBPASS_CONTENTS_INLINE,
PresentInfoKHR( VkPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentInfoKHR) );
+ memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
}
PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PresentInfoKHR) );
+ memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
return *this;
}
-
PresentInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
}
PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
return *this;
}
-
PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) );
}
DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) );
return *this;
}
-
DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ )
{
pNext = pNext_;
MemoryBarrier( VkMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(MemoryBarrier) );
+ memcpy( this, &rhs, sizeof( MemoryBarrier ) );
}
MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(MemoryBarrier) );
+ memcpy( this, &rhs, sizeof( MemoryBarrier ) );
return *this;
}
-
MemoryBarrier& setPNext( const void* pNext_ )
{
pNext = pNext_;
BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
+ memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
}
BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferMemoryBarrier) );
+ memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
return *this;
}
-
BufferMemoryBarrier& setPNext( const void* pNext_ )
{
pNext = pNext_;
BufferCreateInfo( VkBufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferCreateInfo) );
+ memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
}
BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferCreateInfo) );
+ memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
return *this;
}
-
BufferCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
}
DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
return *this;
}
-
DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
{
binding = binding_;
PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
}
PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
return *this;
}
-
PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PushConstantRange( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof(PushConstantRange) );
+ memcpy( this, &rhs, sizeof( PushConstantRange ) );
}
PushConstantRange& operator=( VkPushConstantRange const & rhs )
{
- memcpy( this, &rhs, sizeof(PushConstantRange) );
+ memcpy( this, &rhs, sizeof( PushConstantRange ) );
return *this;
}
-
PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
{
stageFlags = stageFlags_;
PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
}
PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
return *this;
}
-
PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) );
}
PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) );
return *this;
}
-
PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
+ memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
}
ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) );
+ memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
return *this;
}
-
ComputePipelineCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
}
PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
return *this;
}
-
PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
{
blendEnable = blendEnable_;
PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
}
PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
return *this;
}
-
PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
FenceCreateInfo( VkFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(FenceCreateInfo) );
+ memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
}
FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(FenceCreateInfo) );
+ memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
return *this;
}
-
FenceCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
+ memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
}
CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) );
+ memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
return *this;
}
-
CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
+ memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
}
CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) );
+ memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
return *this;
}
-
CommandBufferBeginInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
}
QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
return *this;
}
-
QueryPoolCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImageSubresource( VkImageSubresource const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSubresource) );
+ memcpy( this, &rhs, sizeof( ImageSubresource ) );
}
ImageSubresource& operator=( VkImageSubresource const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSubresource) );
+ memcpy( this, &rhs, sizeof( ImageSubresource ) );
return *this;
}
-
ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
+ memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
}
ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSubresourceLayers) );
+ memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
return *this;
}
-
ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
ImageSubresourceRange( VkImageSubresourceRange const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
+ memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
}
ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageSubresourceRange) );
+ memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
return *this;
}
-
ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
+ memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
}
ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageMemoryBarrier) );
+ memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
return *this;
}
-
ImageMemoryBarrier& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
+ memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
}
ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageViewCreateInfo) );
+ memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
return *this;
}
-
ImageViewCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImageCopy( VkImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageCopy) );
+ memcpy( this, &rhs, sizeof( ImageCopy ) );
}
ImageCopy& operator=( VkImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageCopy) );
+ memcpy( this, &rhs, sizeof( ImageCopy ) );
return *this;
}
-
ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
{
srcSubresource = srcSubresource_;
ImageBlit( VkImageBlit const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageBlit) );
+ memcpy( this, &rhs, sizeof( ImageBlit ) );
}
ImageBlit& operator=( VkImageBlit const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageBlit) );
+ memcpy( this, &rhs, sizeof( ImageBlit ) );
return *this;
}
-
ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
{
srcSubresource = srcSubresource_;
BufferImageCopy( VkBufferImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferImageCopy) );
+ memcpy( this, &rhs, sizeof( BufferImageCopy ) );
}
BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
{
- memcpy( this, &rhs, sizeof(BufferImageCopy) );
+ memcpy( this, &rhs, sizeof( BufferImageCopy ) );
return *this;
}
-
BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
{
bufferOffset = bufferOffset_;
ImageResolve( VkImageResolve const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageResolve) );
+ memcpy( this, &rhs, sizeof( ImageResolve ) );
}
ImageResolve& operator=( VkImageResolve const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageResolve) );
+ memcpy( this, &rhs, sizeof( ImageResolve ) );
return *this;
}
-
ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
{
srcSubresource = srcSubresource_;
ClearAttachment( VkClearAttachment const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearAttachment) );
+ memcpy( this, &rhs, sizeof( ClearAttachment ) );
}
ClearAttachment& operator=( VkClearAttachment const & rhs )
{
- memcpy( this, &rhs, sizeof(ClearAttachment) );
+ memcpy( this, &rhs, sizeof( ClearAttachment ) );
return *this;
}
-
ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
{
aspectMask = aspectMask_;
SparseMemoryBind( VkSparseMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseMemoryBind) );
+ memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
}
SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseMemoryBind) );
+ memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
return *this;
}
-
SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
{
resourceOffset = resourceOffset_;
SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
}
SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBind) );
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
return *this;
}
-
SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
{
subresource = subresource_;
SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
+ memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
}
SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) );
+ memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
return *this;
}
-
SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
{
buffer = buffer_;
SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
+ memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
}
SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) );
+ memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
return *this;
}
-
SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
{
image = image_;
SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
}
SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) );
+ memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
return *this;
}
-
SparseImageMemoryBindInfo& setImage( Image image_ )
{
image = image_;
BindSparseInfo( VkBindSparseInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(BindSparseInfo) );
+ memcpy( this, &rhs, sizeof( BindSparseInfo ) );
}
BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(BindSparseInfo) );
+ memcpy( this, &rhs, sizeof( BindSparseInfo ) );
return *this;
}
-
BindSparseInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
}
CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
return *this;
}
-
CommandPoolCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImageCreateInfo( VkImageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageCreateInfo) );
+ memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
}
ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(ImageCreateInfo) );
+ memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
return *this;
}
-
ImageCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
}
PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) );
+ memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
return *this;
}
-
PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
+ memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
}
GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) );
+ memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
return *this;
}
-
GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) );
}
PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) );
return *this;
}
-
PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
AttachmentDescription( VkAttachmentDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(AttachmentDescription) );
+ memcpy( this, &rhs, sizeof( AttachmentDescription ) );
}
AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(AttachmentDescription) );
+ memcpy( this, &rhs, sizeof( AttachmentDescription ) );
return *this;
}
-
AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
{
flags = flags_;
DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
}
DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
return *this;
}
-
DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
SubpassDependency( VkSubpassDependency const & rhs )
{
- memcpy( this, &rhs, sizeof(SubpassDependency) );
+ memcpy( this, &rhs, sizeof( SubpassDependency ) );
}
SubpassDependency& operator=( VkSubpassDependency const & rhs )
{
- memcpy( this, &rhs, sizeof(SubpassDependency) );
+ memcpy( this, &rhs, sizeof( SubpassDependency ) );
return *this;
}
-
SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
{
srcSubpass = srcSubpass_;
DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
}
DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
return *this;
}
-
DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
}
DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
return *this;
}
-
DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
- eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT,
+ eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
}
DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
return *this;
}
-
DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
}
DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) );
+ memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
return *this;
}
-
DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
};
static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
- enum class DebugReportErrorEXT
- {
- eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT,
- eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT
- };
-
enum class RasterizationOrderAMD
{
eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
}
PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) );
+ memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
return *this;
}
-
PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
}
ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
return *this;
}
-
ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
}
ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) );
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
return *this;
}
-
ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
}
ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) );
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
return *this;
}
-
ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
enum class ValidationCheckEXT
{
- eAll = VK_VALIDATION_CHECK_ALL_EXT
+ eAll = VK_VALIDATION_CHECK_ALL_EXT,
+ eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
};
struct ValidationFlagsEXT
ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
+ memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
}
ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(ValidationFlagsEXT) );
+ memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
return *this;
}
-
ValidationFlagsEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) );
+ memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
}
IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) );
+ memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
return *this;
}
-
IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
{
tokenType = tokenType_;
IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) );
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
}
IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) );
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
return *this;
}
-
IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
{
tokenType = tokenType_;
IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
}
IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
return *this;
}
-
IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
}
ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
return *this;
}
-
ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
}
ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
return *this;
}
-
ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
type = type_;
ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
}
ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
return *this;
}
-
ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
type = type_;
ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
}
ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
return *this;
}
-
ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
type = type_;
ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
}
ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
return *this;
}
-
ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
type = type_;
ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
}
ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
return *this;
}
-
ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
type = type_;
ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
}
ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) );
+ memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
return *this;
}
-
ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
{
type = type_;
DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
}
DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) );
+ memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
return *this;
}
-
DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceExternalImageFormatInfoKHX( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) );
}
PhysicalDeviceExternalImageFormatInfoKHX& operator=( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) );
return *this;
}
-
PhysicalDeviceExternalImageFormatInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceExternalBufferInfoKHX( VkPhysicalDeviceExternalBufferInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHX ) );
}
PhysicalDeviceExternalBufferInfoKHX& operator=( VkPhysicalDeviceExternalBufferInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHX ) );
return *this;
}
-
PhysicalDeviceExternalBufferInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExternalMemoryImageCreateInfoKHX( VkExternalMemoryImageCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHX ) );
}
ExternalMemoryImageCreateInfoKHX& operator=( VkExternalMemoryImageCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHX ) );
return *this;
}
-
ExternalMemoryImageCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExternalMemoryBufferCreateInfoKHX( VkExternalMemoryBufferCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHX ) );
}
ExternalMemoryBufferCreateInfoKHX& operator=( VkExternalMemoryBufferCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHX ) );
return *this;
}
-
ExternalMemoryBufferCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExportMemoryAllocateInfoKHX( VkExportMemoryAllocateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHX ) );
}
ExportMemoryAllocateInfoKHX& operator=( VkExportMemoryAllocateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHX ) );
return *this;
}
-
ExportMemoryAllocateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImportMemoryWin32HandleInfoKHX( VkImportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHX ) );
}
ImportMemoryWin32HandleInfoKHX& operator=( VkImportMemoryWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHX ) );
return *this;
}
-
ImportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImportMemoryFdInfoKHX( VkImportMemoryFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHX ) );
}
ImportMemoryFdInfoKHX& operator=( VkImportMemoryFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHX ) );
return *this;
}
-
ImportMemoryFdInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
PhysicalDeviceExternalSemaphoreInfoKHX( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) );
}
PhysicalDeviceExternalSemaphoreInfoKHX& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) );
+ memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) );
return *this;
}
-
PhysicalDeviceExternalSemaphoreInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ExportSemaphoreCreateInfoKHX( VkExportSemaphoreCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHX ) );
}
ExportSemaphoreCreateInfoKHX& operator=( VkExportSemaphoreCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHX ) );
return *this;
}
-
ExportSemaphoreCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImportSemaphoreWin32HandleInfoKHX( VkImportSemaphoreWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHX ) );
}
ImportSemaphoreWin32HandleInfoKHX& operator=( VkImportSemaphoreWin32HandleInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHX ) );
return *this;
}
-
ImportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
ImportSemaphoreFdInfoKHX( VkImportSemaphoreFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHX ) );
}
ImportSemaphoreFdInfoKHX& operator=( VkImportSemaphoreFdInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) );
+ memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHX ) );
return *this;
}
-
ImportSemaphoreFdInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
}
SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
return *this;
}
-
SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) );
+ memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
}
DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) );
+ memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
return *this;
}
-
DisplayPowerInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) );
+ memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
}
DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) );
+ memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
return *this;
}
-
DeviceEventInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) );
+ memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
}
DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) );
+ memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
return *this;
}
-
DisplayEventInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
MemoryAllocateFlagsInfoKHX( VkMemoryAllocateFlagsInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) );
+ memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) );
}
MemoryAllocateFlagsInfoKHX& operator=( VkMemoryAllocateFlagsInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) );
+ memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) );
return *this;
}
-
MemoryAllocateFlagsInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGroupPresentInfoKHX( VkDeviceGroupPresentInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) );
}
DeviceGroupPresentInfoKHX& operator=( VkDeviceGroupPresentInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) );
return *this;
}
-
DeviceGroupPresentInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
DeviceGroupSwapchainCreateInfoKHX( VkDeviceGroupSwapchainCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) );
}
DeviceGroupSwapchainCreateInfoKHX& operator=( VkDeviceGroupSwapchainCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) );
return *this;
}
-
DeviceGroupSwapchainCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
}
SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
{
- memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) );
+ memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
return *this;
}
-
SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
{
pNext = pNext_;
ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ViewportSwizzleNV) );
+ memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
}
ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs )
{
- memcpy( this, &rhs, sizeof(ViewportSwizzleNV) );
+ memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
return *this;
}
-
ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ )
{
x = x_;
PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
}
PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) );
+ memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
return *this;
}
-
PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ )
{
pNext = pNext_;
PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
}
PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
{
- memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) );
+ memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
return *this;
}
-
PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ )
{
pNext = pNext_;
SubpassDescription( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(SubpassDescription) );
+ memcpy( this, &rhs, sizeof( SubpassDescription ) );
}
SubpassDescription& operator=( VkSubpassDescription const & rhs )
{
- memcpy( this, &rhs, sizeof(SubpassDescription) );
+ memcpy( this, &rhs, sizeof( SubpassDescription ) );
return *this;
}
-
SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
{
flags = flags_;
RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
+ memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
}
RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(RenderPassCreateInfo) );
+ memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
return *this;
}
-
RenderPassCreateInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
};
static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
- Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties );
+ Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template <typename Allocator = std::allocator<LayerProperties>>
- typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties();
+ template <typename Allocator = std::allocator<LayerProperties>>
+ typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties();
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties )
result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::enumerateInstanceLayerProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
- Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties );
+ Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- template <typename Allocator = std::allocator<ExtensionProperties>>
- typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr );
+ template <typename Allocator = std::allocator<ExtensionProperties>>
+ typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties )
result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::enumerateInstanceExtensionProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
: m_commandBuffer(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer(VkCommandBuffer commandBuffer)
- : m_commandBuffer(commandBuffer)
+ VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer )
+ : m_commandBuffer( commandBuffer )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- CommandBuffer& operator=(VkCommandBuffer commandBuffer)
+ CommandBuffer & operator=(VkCommandBuffer commandBuffer)
{
m_commandBuffer = commandBuffer;
- return *this;
+ return *this;
}
#endif
- CommandBuffer& operator=( std::nullptr_t )
+ CommandBuffer & operator=( std::nullptr_t )
{
m_commandBuffer = VK_NULL_HANDLE;
return *this;
}
- bool operator==(CommandBuffer const &rhs) const
+ bool operator==( CommandBuffer const & rhs ) const
{
return m_commandBuffer == rhs.m_commandBuffer;
}
- bool operator!=(CommandBuffer const &rhs) const
+ bool operator!=(CommandBuffer const & rhs ) const
{
return m_commandBuffer != rhs.m_commandBuffer;
}
- bool operator<(CommandBuffer const &rhs) const
+ bool operator<(CommandBuffer const & rhs ) const
{
return m_commandBuffer < rhs.m_commandBuffer;
}
void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
{
return m_commandBuffer;
private:
VkCommandBuffer m_commandBuffer;
};
+
static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo ) const
#else
if ( buffers.size() != offsets.size() )
{
- throw std::logic_error( "vk::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
+ throw LogicError( "vk::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
}
#endif // VULKAN_HPP_NO_EXCEPTIONS
vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data() );
SubmitInfo( VkSubmitInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SubmitInfo) );
+ memcpy( this, &rhs, sizeof( SubmitInfo ) );
}
SubmitInfo& operator=( VkSubmitInfo const & rhs )
{
- memcpy( this, &rhs, sizeof(SubmitInfo) );
+ memcpy( this, &rhs, sizeof( SubmitInfo ) );
return *this;
}
-
SubmitInfo& setPNext( const void* pNext_ )
{
pNext = pNext_;
: m_queue(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Queue(VkQueue queue)
- : m_queue(queue)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue )
+ : m_queue( queue )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Queue& operator=(VkQueue queue)
+ Queue & operator=(VkQueue queue)
{
m_queue = queue;
- return *this;
+ return *this;
}
#endif
- Queue& operator=( std::nullptr_t )
+ Queue & operator=( std::nullptr_t )
{
m_queue = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Queue const &rhs) const
+ bool operator==( Queue const & rhs ) const
{
return m_queue == rhs.m_queue;
}
- bool operator!=(Queue const &rhs) const
+ bool operator!=(Queue const & rhs ) const
{
return m_queue != rhs.m_queue;
}
- bool operator<(Queue const &rhs) const
+ bool operator<(Queue const & rhs ) const
{
return m_queue < rhs.m_queue;
}
Result presentKHR( const PresentInfoKHR & presentInfo ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const
{
return m_queue;
private:
VkQueue m_queue;
};
+
static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const
: m_device(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Device(VkDevice device)
- : m_device(device)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device )
+ : m_device( device )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Device& operator=(VkDevice device)
+ Device & operator=(VkDevice device)
{
m_device = device;
- return *this;
+ return *this;
}
#endif
- Device& operator=( std::nullptr_t )
+ Device & operator=( std::nullptr_t )
{
m_device = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Device const &rhs) const
+ bool operator==( Device const & rhs ) const
{
return m_device == rhs.m_device;
}
- bool operator!=(Device const &rhs) const
+ bool operator!=(Device const & rhs ) const
{
return m_device != rhs.m_device;
}
- bool operator<(Device const &rhs) const
+ bool operator<(Device const & rhs ) const
{
return m_device < rhs.m_device;
}
typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
{
return m_device;
private:
VkDevice m_device;
};
+
static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
#ifndef VULKAN_HPP_NO_SMART_HANDLE
result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( dataSize <= data.size() );
- data.resize( dataSize );
+ assert( dataSize <= data.size() );
+ data.resize( dataSize );
return createResultValue( result, data, "vk::Device::getPipelineCacheData" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( swapchainImageCount <= swapchainImages.size() );
- swapchainImages.resize( swapchainImageCount );
+ assert( swapchainImageCount <= swapchainImages.size() );
+ swapchainImages.resize( swapchainImageCount );
return createResultValue( result, swapchainImages, "vk::Device::getSwapchainImagesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#else
if ( pObjectTableEntries.size() != objectIndices.size() )
{
- throw std::logic_error( "vk::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" );
+ throw LogicError( "vk::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" );
}
#endif // VULKAN_HPP_NO_EXCEPTIONS
Result result = static_cast<Result>( vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), pObjectTableEntries.size() , reinterpret_cast<const VkObjectTableEntryNVX* const*>( pObjectTableEntries.data() ), objectIndices.data() ) );
#else
if ( objectEntryTypes.size() != objectIndices.size() )
{
- throw std::logic_error( "vk::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" );
+ throw LogicError( "vk::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" );
}
#endif // VULKAN_HPP_NO_EXCEPTIONS
Result result = static_cast<Result>( vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectEntryTypes.size() , reinterpret_cast<const VkObjectEntryTypeNVX*>( objectEntryTypes.data() ), objectIndices.data() ) );
#else
if ( swapchains.size() != metadata.size() )
{
- throw std::logic_error( "vk::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
+ throw LogicError( "vk::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
}
#endif // VULKAN_HPP_NO_EXCEPTIONS
vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast<const VkSwapchainKHR*>( swapchains.data() ), reinterpret_cast<const VkHdrMetadataEXT*>( metadata.data() ) );
: m_physicalDevice(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice(VkPhysicalDevice physicalDevice)
- : m_physicalDevice(physicalDevice)
+ VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice )
+ : m_physicalDevice( physicalDevice )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- PhysicalDevice& operator=(VkPhysicalDevice physicalDevice)
+ PhysicalDevice & operator=(VkPhysicalDevice physicalDevice)
{
m_physicalDevice = physicalDevice;
- return *this;
+ return *this;
}
#endif
- PhysicalDevice& operator=( std::nullptr_t )
+ PhysicalDevice & operator=( std::nullptr_t )
{
m_physicalDevice = VK_NULL_HANDLE;
return *this;
}
- bool operator==(PhysicalDevice const &rhs) const
+ bool operator==( PhysicalDevice const & rhs ) const
{
return m_physicalDevice == rhs.m_physicalDevice;
}
- bool operator!=(PhysicalDevice const &rhs) const
+ bool operator!=(PhysicalDevice const & rhs ) const
{
return m_physicalDevice != rhs.m_physicalDevice;
}
- bool operator<(PhysicalDevice const &rhs) const
+ bool operator<(PhysicalDevice const & rhs ) const
{
return m_physicalDevice < rhs.m_physicalDevice;
}
Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
+ ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const;
typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
{
return m_physicalDevice;
private:
VkPhysicalDevice m_physicalDevice;
};
+
static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
#ifndef VULKAN_HPP_NO_SMART_HANDLE
result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::PhysicalDevice::enumerateDeviceLayerProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::PhysicalDevice::enumerateDeviceExtensionProperties" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayPropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayPlanePropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( displayCount <= displays.size() );
- displays.resize( displayCount );
+ assert( displayCount <= displays.size() );
+ displays.resize( displayCount );
return createResultValue( result, displays, "vk::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( propertyCount <= properties.size() );
- properties.resize( propertyCount );
+ assert( propertyCount <= properties.size() );
+ properties.resize( propertyCount );
return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayModePropertiesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( surfaceFormatCount <= surfaceFormats.size() );
- surfaceFormats.resize( surfaceFormatCount );
+ assert( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormatsKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( presentModeCount <= presentModes.size() );
- presentModes.resize( presentModeCount );
+ assert( presentModeCount <= presentModes.size() );
+ presentModes.resize( presentModeCount );
return createResultValue( result, presentModes, "vk::PhysicalDevice::getSurfacePresentModesKHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( rectCount <= rects.size() );
- rects.resize( rectCount );
+ assert( rectCount <= rects.size() );
+ rects.resize( rectCount );
return createResultValue( result, rects, "vk::PhysicalDevice::getPresentRectanglesKHX" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-#if 0 // LunarG 1.0.48 header update workaround
- VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
+ VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
{
+ SurfaceCapabilities2KHR surfaceCapabilities;
Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilities2KHR" );
}
-#endif
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const
result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( surfaceFormatCount <= surfaceFormats.size() );
- surfaceFormats.resize( surfaceFormatCount );
+ assert( surfaceFormatCount <= surfaceFormats.size() );
+ surfaceFormats.resize( surfaceFormatCount );
return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormats2KHR" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) );
+ memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
}
CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
{
- memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) );
+ memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
return *this;
}
-
CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ )
{
pNext = pNext_;
: m_instance(VK_NULL_HANDLE)
{}
- VULKAN_HPP_TYPESAFE_EXPLICIT Instance(VkInstance instance)
- : m_instance(instance)
+ VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance )
+ : m_instance( instance )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
- Instance& operator=(VkInstance instance)
+ Instance & operator=(VkInstance instance)
{
m_instance = instance;
- return *this;
+ return *this;
}
#endif
- Instance& operator=( std::nullptr_t )
+ Instance & operator=( std::nullptr_t )
{
m_instance = VK_NULL_HANDLE;
return *this;
}
- bool operator==(Instance const &rhs) const
+ bool operator==( Instance const & rhs ) const
{
return m_instance == rhs.m_instance;
}
- bool operator!=(Instance const &rhs) const
+ bool operator!=(Instance const & rhs ) const
{
return m_instance != rhs.m_instance;
}
- bool operator<(Instance const &rhs) const
+ bool operator<(Instance const & rhs ) const
{
return m_instance < rhs.m_instance;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
{
return m_instance;
private:
VkInstance m_instance;
};
+
static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
#ifndef VULKAN_HPP_NO_SMART_HANDLE
result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( physicalDeviceCount <= physicalDevices.size() );
- physicalDevices.resize( physicalDeviceCount );
+ assert( physicalDeviceCount <= physicalDevices.size() );
+ physicalDevices.resize( physicalDeviceCount );
return createResultValue( result, physicalDevices, "vk::Instance::enumeratePhysicalDevices" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#else
if ( layerPrefix.size() != message.size() )
{
- throw std::logic_error( "vk::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
+ throw LogicError( "vk::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
}
#endif // VULKAN_HPP_NO_EXCEPTIONS
vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( physicalDeviceGroupProperties.data() ) ) );
}
} while ( result == Result::eIncomplete );
- assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
- physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
+ assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
+ physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
return createResultValue( result, physicalDeviceGroupProperties, "vk::Instance::enumeratePhysicalDeviceGroupsKHX" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
DeviceGroupDeviceCreateInfoKHX( VkDeviceGroupDeviceCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) );
}
DeviceGroupDeviceCreateInfoKHX& operator=( VkDeviceGroupDeviceCreateInfoKHX const & rhs )
{
- memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) );
+ memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) );
return *this;
}
-
DeviceGroupDeviceCreateInfoKHX& setPNext( const void* pNext_ )
{
pNext = pNext_;
using UniqueInstance = UniqueHandle<Instance, InstanceDeleter>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
- Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance );
+ Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
- ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr );
+ ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr );
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- UniqueInstance createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr );
+ UniqueInstance createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr );
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
+ case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD";
case StructureType::eRenderPassMultiviewCreateInfoKHX: return "RenderPassMultiviewCreateInfoKHX";
case StructureType::ePhysicalDeviceMultiviewFeaturesKHX: return "PhysicalDeviceMultiviewFeaturesKHX";
case StructureType::ePhysicalDeviceMultiviewPropertiesKHX: return "PhysicalDeviceMultiviewPropertiesKHX";
case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool";
case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr";
case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr";
- case DebugReportObjectTypeEXT::eDebugReport: return "DebugReport";
+ case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt";
case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr";
case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr";
case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx";
}
}
- VULKAN_HPP_INLINE std::string to_string(DebugReportErrorEXT value)
- {
- switch (value)
- {
- case DebugReportErrorEXT::eNone: return "None";
- case DebugReportErrorEXT::eCallbackRef: return "CallbackRef";
- default: return "invalid";
- }
- }
-
VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value)
{
switch (value)
switch (value)
{
case ValidationCheckEXT::eAll: return "All";
+ case ValidationCheckEXT::eShaders: return "Shaders";
default: return "invalid";
}
}
projects / platform / upstream / Vulkan-Tools.git / commitdiff