-// Copyright (c) 2015-2017 The Khronos Group Inc.
+// Copyright (c) 2015-2018 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
# include <memory>
# include <vector>
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-static_assert( VK_HEADER_VERSION == 66 , "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 67 , "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
{
}
+ explicit Flags(MaskType flags)
+ : m_mask(flags)
+ {
+ }
+
Flags<BitType> & operator=(Flags<BitType> const& rhs)
{
m_mask = rhs.m_mask;
#endif
#ifndef VULKAN_HPP_NO_SMART_HANDLE
- template <typename Type, typename Deleter>
- class UniqueHandle
+
+ template <typename Type> class UniqueHandleTraits;
+
+ template <typename Type>
+ class UniqueHandle : public UniqueHandleTraits<Type>::deleter
{
+ private:
+ using Deleter = typename UniqueHandleTraits<Type>::deleter;
public:
explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
- : m_value( value )
- , m_deleter( deleter )
+ : Deleter( deleter)
+ , m_value( value )
{}
UniqueHandle( UniqueHandle const& ) = delete;
UniqueHandle( UniqueHandle && other )
- : m_value( other.release() )
- , m_deleter( std::move( other.m_deleter ) )
+ : Deleter( std::move( static_cast<Deleter&>( other ) ) )
+ , m_value( other.release() )
{}
~UniqueHandle()
{
- destroy();
+ this->destroy( m_value );
}
UniqueHandle & operator=( UniqueHandle const& ) = delete;
UniqueHandle & operator=( UniqueHandle && other )
{
reset( other.release() );
- m_deleter = std::move( other.m_deleter );
+ *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
return *this;
}
return m_value;
}
- Deleter & getDeleter()
- {
- return m_deleter;
- }
-
- Deleter const& getDeleter() const
- {
- return m_deleter;
- }
-
void reset( Type const& value = Type() )
{
if ( m_value != value )
{
- destroy();
+ this->destroy( m_value );
m_value = value;
}
}
return value;
}
- void swap( UniqueHandle<Type, Deleter> & rhs )
+ void swap( UniqueHandle<Type> & rhs )
{
std::swap(m_value, rhs.m_value);
- std::swap(m_deleter, rhs.m_deleter);
- }
-
- private:
- void destroy()
- {
- if ( m_value )
- {
- m_deleter( m_value );
- }
+ std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
}
private:
Type m_value;
- Deleter m_deleter;
};
- template <typename Type, typename Deleter>
- VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Deleter> & lhs, UniqueHandle<Type,Deleter> & rhs )
+ template <typename Type>
+ VULKAN_HPP_INLINE void swap( UniqueHandle<Type> & lhs, UniqueHandle<Type> & rhs )
{
lhs.swap( rhs );
}
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 );
using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT>;
+ enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT
+ {
+ };
+
+ using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>;
+
class DeviceMemory
{
public:
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
- : m_deviceMemory( deviceMemory )
+ : m_deviceMemory( deviceMemory )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
- : m_commandPool( commandPool )
+ : m_commandPool( commandPool )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer )
- : m_buffer( buffer )
+ : m_buffer( buffer )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
- : m_bufferView( bufferView )
+ : m_bufferView( bufferView )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image )
- : m_image( image )
+ : m_image( image )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView )
- : m_imageView( imageView )
+ : m_imageView( imageView )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
- : m_shaderModule( shaderModule )
+ : m_shaderModule( shaderModule )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline )
- : m_pipeline( pipeline )
+ : m_pipeline( pipeline )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
- : m_pipelineLayout( pipelineLayout )
+ : m_pipelineLayout( pipelineLayout )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler )
- : m_sampler( sampler )
+ : m_sampler( sampler )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
- : m_descriptorSet( descriptorSet )
+ : m_descriptorSet( descriptorSet )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
- : m_descriptorSetLayout( descriptorSetLayout )
+ : m_descriptorSetLayout( descriptorSetLayout )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
- : m_descriptorPool( descriptorPool )
+ : m_descriptorPool( descriptorPool )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence )
- : m_fence( fence )
+ : m_fence( fence )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore )
- : m_semaphore( semaphore )
+ : m_semaphore( semaphore )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event )
- : m_event( event )
+ : m_event( event )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool )
- : m_queryPool( queryPool )
+ : m_queryPool( queryPool )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer )
- : m_framebuffer( framebuffer )
+ : m_framebuffer( framebuffer )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
- : m_renderPass( renderPass )
+ : m_renderPass( renderPass )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
- : m_pipelineCache( pipelineCache )
+ : m_pipelineCache( pipelineCache )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
- : m_objectTableNVX( objectTableNVX )
+ : m_objectTableNVX( objectTableNVX )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
- : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
+ : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
- : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR )
+ : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversionKHR( VkSamplerYcbcrConversionKHR samplerYcbcrConversionKHR )
- : m_samplerYcbcrConversionKHR( samplerYcbcrConversionKHR )
+ : m_samplerYcbcrConversionKHR( samplerYcbcrConversionKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT )
- : m_validationCacheEXT( validationCacheEXT )
+ : m_validationCacheEXT( validationCacheEXT )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
- : m_displayKHR( displayKHR )
+ : m_displayKHR( displayKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
- : m_displayModeKHR( displayModeKHR )
+ : m_displayModeKHR( displayModeKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
- : m_surfaceKHR( surfaceKHR )
+ : m_surfaceKHR( surfaceKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
- : m_swapchainKHR( swapchainKHR )
+ : m_swapchainKHR( swapchainKHR )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
{}
VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
- : m_debugReportCallbackEXT( debugReportCallbackEXT )
+ : m_debugReportCallbackEXT( debugReportCallbackEXT )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
+ ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
+ ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
struct ApplicationInfo
{
ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 )
- : sType( StructureType::eApplicationInfo )
- , pNext( nullptr )
- , pApplicationName( pApplicationName_ )
+ : pApplicationName( pApplicationName_ )
, applicationVersion( applicationVersion_ )
, pEngineName( pEngineName_ )
, engineVersion( engineVersion_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eApplicationInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
const char* pApplicationName;
uint32_t applicationVersion;
const char* pEngineName;
struct DeviceQueueCreateInfo
{
DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr )
- : sType( StructureType::eDeviceQueueCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, queueFamilyIndex( queueFamilyIndex_ )
, queueCount( queueCount_ )
, pQueuePriorities( pQueuePriorities_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceQueueCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceQueueCreateFlags flags;
uint32_t queueFamilyIndex;
uint32_t queueCount;
struct DeviceCreateInfo
{
DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
- : sType( StructureType::eDeviceCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, queueCreateInfoCount( queueCreateInfoCount_ )
, pQueueCreateInfos( pQueueCreateInfos_ )
, enabledLayerCount( enabledLayerCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceCreateFlags flags;
uint32_t queueCreateInfoCount;
const DeviceQueueCreateInfo* pQueueCreateInfos;
struct InstanceCreateInfo
{
InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), const ApplicationInfo* pApplicationInfo_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr )
- : sType( StructureType::eInstanceCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, pApplicationInfo( pApplicationInfo_ )
, enabledLayerCount( enabledLayerCount_ )
, ppEnabledLayerNames( ppEnabledLayerNames_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eInstanceCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
InstanceCreateFlags flags;
const ApplicationInfo* pApplicationInfo;
uint32_t enabledLayerCount;
struct MemoryAllocateInfo
{
MemoryAllocateInfo( DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 )
- : sType( StructureType::eMemoryAllocateInfo )
- , pNext( nullptr )
- , allocationSize( allocationSize_ )
+ : allocationSize( allocationSize_ )
, memoryTypeIndex( memoryTypeIndex_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryAllocateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceSize allocationSize;
uint32_t memoryTypeIndex;
};
struct MappedMemoryRange
{
MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
- : sType( StructureType::eMappedMemoryRange )
- , pNext( nullptr )
- , memory( memory_ )
+ : memory( memory_ )
, offset( offset_ )
, size( size_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMappedMemoryRange;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceMemory memory;
DeviceSize offset;
DeviceSize size;
struct WriteDescriptorSet
{
WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, const DescriptorImageInfo* pImageInfo_ = nullptr, const DescriptorBufferInfo* pBufferInfo_ = nullptr, const BufferView* pTexelBufferView_ = nullptr )
- : sType( StructureType::eWriteDescriptorSet )
- , pNext( nullptr )
- , dstSet( dstSet_ )
+ : dstSet( dstSet_ )
, dstBinding( dstBinding_ )
, dstArrayElement( dstArrayElement_ )
, descriptorCount( descriptorCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eWriteDescriptorSet;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
struct CopyDescriptorSet
{
CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), uint32_t srcBinding_ = 0, uint32_t srcArrayElement_ = 0, DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 )
- : sType( StructureType::eCopyDescriptorSet )
- , pNext( nullptr )
- , srcSet( srcSet_ )
+ : srcSet( srcSet_ )
, srcBinding( srcBinding_ )
, srcArrayElement( srcArrayElement_ )
, dstSet( dstSet_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCopyDescriptorSet;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DescriptorSet srcSet;
uint32_t srcBinding;
uint32_t srcArrayElement;
struct BufferViewCreateInfo
{
BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), Buffer buffer_ = Buffer(), Format format_ = Format::eUndefined, DeviceSize offset_ = 0, DeviceSize range_ = 0 )
- : sType( StructureType::eBufferViewCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, buffer( buffer_ )
, format( format_ )
, offset( offset_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBufferViewCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
BufferViewCreateFlags flags;
Buffer buffer;
Format format;
struct ShaderModuleCreateInfo
{
ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr )
- : sType( StructureType::eShaderModuleCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, codeSize( codeSize_ )
, pCode( pCode_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eShaderModuleCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ShaderModuleCreateFlags flags;
size_t codeSize;
const uint32_t* pCode;
struct DescriptorSetAllocateInfo
{
DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), uint32_t descriptorSetCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr )
- : sType( StructureType::eDescriptorSetAllocateInfo )
- , pNext( nullptr )
- , descriptorPool( descriptorPool_ )
+ : descriptorPool( descriptorPool_ )
, descriptorSetCount( descriptorSetCount_ )
, pSetLayouts( pSetLayouts_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDescriptorSetAllocateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DescriptorPool descriptorPool;
uint32_t descriptorSetCount;
const DescriptorSetLayout* pSetLayouts;
struct PipelineVertexInputStateCreateInfo
{
PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
- : sType( StructureType::ePipelineVertexInputStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
, pVertexBindingDescriptions( pVertexBindingDescriptions_ )
, vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineVertexInputStateCreateFlags flags;
uint32_t vertexBindingDescriptionCount;
const VertexInputBindingDescription* pVertexBindingDescriptions;
struct PipelineInputAssemblyStateCreateInfo
{
PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_ = PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_ = 0 )
- : sType( StructureType::ePipelineInputAssemblyStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, topology( topology_ )
, primitiveRestartEnable( primitiveRestartEnable_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineInputAssemblyStateCreateFlags flags;
PrimitiveTopology topology;
Bool32 primitiveRestartEnable;
struct PipelineTessellationStateCreateInfo
{
PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 )
- : sType( StructureType::ePipelineTessellationStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, patchControlPoints( patchControlPoints_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineTessellationStateCreateFlags flags;
uint32_t patchControlPoints;
};
struct PipelineViewportStateCreateInfo
{
PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const Rect2D* pScissors_ = nullptr )
- : sType( StructureType::ePipelineViewportStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, viewportCount( viewportCount_ )
, pViewports( pViewports_ )
, scissorCount( scissorCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineViewportStateCreateFlags flags;
uint32_t viewportCount;
const Viewport* pViewports;
struct PipelineRasterizationStateCreateInfo
{
PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), Bool32 depthClampEnable_ = 0, Bool32 rasterizerDiscardEnable_ = 0, PolygonMode polygonMode_ = PolygonMode::eFill, CullModeFlags cullMode_ = CullModeFlags(), FrontFace frontFace_ = FrontFace::eCounterClockwise, Bool32 depthBiasEnable_ = 0, float depthBiasConstantFactor_ = 0, float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 )
- : sType( StructureType::ePipelineRasterizationStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, depthClampEnable( depthClampEnable_ )
, rasterizerDiscardEnable( rasterizerDiscardEnable_ )
, polygonMode( polygonMode_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineRasterizationStateCreateFlags flags;
Bool32 depthClampEnable;
Bool32 rasterizerDiscardEnable;
struct PipelineDepthStencilStateCreateInfo
{
PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), Bool32 depthTestEnable_ = 0, Bool32 depthWriteEnable_ = 0, CompareOp depthCompareOp_ = CompareOp::eNever, Bool32 depthBoundsTestEnable_ = 0, Bool32 stencilTestEnable_ = 0, StencilOpState front_ = StencilOpState(), StencilOpState back_ = StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 )
- : sType( StructureType::ePipelineDepthStencilStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, depthTestEnable( depthTestEnable_ )
, depthWriteEnable( depthWriteEnable_ )
, depthCompareOp( depthCompareOp_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineDepthStencilStateCreateFlags flags;
Bool32 depthTestEnable;
Bool32 depthWriteEnable;
struct PipelineCacheCreateInfo
{
PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
- : sType( StructureType::ePipelineCacheCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, initialDataSize( initialDataSize_ )
, pInitialData( pInitialData_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineCacheCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineCacheCreateFlags flags;
size_t initialDataSize;
const void* pInitialData;
struct SamplerCreateInfo
{
SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), Filter magFilter_ = Filter::eNearest, Filter minFilter_ = Filter::eNearest, SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, float mipLodBias_ = 0, Bool32 anisotropyEnable_ = 0, float maxAnisotropy_ = 0, Bool32 compareEnable_ = 0, CompareOp compareOp_ = CompareOp::eNever, float minLod_ = 0, float maxLod_ = 0, BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, Bool32 unnormalizedCoordinates_ = 0 )
- : sType( StructureType::eSamplerCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, magFilter( magFilter_ )
, minFilter( minFilter_ )
, mipmapMode( mipmapMode_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSamplerCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SamplerCreateFlags flags;
Filter magFilter;
Filter minFilter;
struct CommandBufferAllocateInfo
{
CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), CommandBufferLevel level_ = CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 )
- : sType( StructureType::eCommandBufferAllocateInfo )
- , pNext( nullptr )
- , commandPool( commandPool_ )
+ : commandPool( commandPool_ )
, level( level_ )
, commandBufferCount( commandBufferCount_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCommandBufferAllocateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
CommandPool commandPool;
CommandBufferLevel level;
uint32_t commandBufferCount;
struct RenderPassBeginInfo
{
RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), Framebuffer framebuffer_ = Framebuffer(), Rect2D renderArea_ = Rect2D(), uint32_t clearValueCount_ = 0, const ClearValue* pClearValues_ = nullptr )
- : sType( StructureType::eRenderPassBeginInfo )
- , pNext( nullptr )
- , renderPass( renderPass_ )
+ : renderPass( renderPass_ )
, framebuffer( framebuffer_ )
, renderArea( renderArea_ )
, clearValueCount( clearValueCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eRenderPassBeginInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
RenderPass renderPass;
Framebuffer framebuffer;
Rect2D renderArea;
struct EventCreateInfo
{
EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
- : sType( StructureType::eEventCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eEventCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
EventCreateFlags flags;
};
static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
struct SemaphoreCreateInfo
{
SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
- : sType( StructureType::eSemaphoreCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSemaphoreCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SemaphoreCreateFlags flags;
};
static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
struct FramebufferCreateInfo
{
FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), RenderPass renderPass_ = RenderPass(), uint32_t attachmentCount_ = 0, const ImageView* pAttachments_ = nullptr, uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 )
- : sType( StructureType::eFramebufferCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, renderPass( renderPass_ )
, attachmentCount( attachmentCount_ )
, pAttachments( pAttachments_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eFramebufferCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
FramebufferCreateFlags flags;
RenderPass renderPass;
uint32_t attachmentCount;
struct DisplayModeCreateInfoKHR
{
DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
- : sType( StructureType::eDisplayModeCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, parameters( parameters_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DisplayModeCreateFlagsKHR flags;
DisplayModeParametersKHR parameters;
};
struct DisplayPresentInfoKHR
{
DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), Rect2D dstRect_ = Rect2D(), Bool32 persistent_ = 0 )
- : sType( StructureType::eDisplayPresentInfoKHR )
- , pNext( nullptr )
- , srcRect( srcRect_ )
+ : srcRect( srcRect_ )
, dstRect( dstRect_ )
, persistent( persistent_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDisplayPresentInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Rect2D srcRect;
Rect2D dstRect;
Bool32 persistent;
struct AndroidSurfaceCreateInfoKHR
{
AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), ANativeWindow* window_ = nullptr )
- : sType( StructureType::eAndroidSurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, window( window_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
AndroidSurfaceCreateFlagsKHR flags;
ANativeWindow* window;
};
struct MirSurfaceCreateInfoKHR
{
MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), MirConnection* connection_ = nullptr, MirSurface* mirSurface_ = nullptr )
- : sType( StructureType::eMirSurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, connection( connection_ )
, mirSurface( mirSurface_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMirSurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
MirSurfaceCreateFlagsKHR flags;
MirConnection* connection;
MirSurface* mirSurface;
struct ViSurfaceCreateInfoNN
{
ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), void* window_ = nullptr )
- : sType( StructureType::eViSurfaceCreateInfoNN )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, window( window_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eViSurfaceCreateInfoNN;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ViSurfaceCreateFlagsNN flags;
void* window;
};
struct WaylandSurfaceCreateInfoKHR
{
WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr )
- : sType( StructureType::eWaylandSurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, display( display_ )
, surface( surface_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
WaylandSurfaceCreateFlagsKHR flags;
struct wl_display* display;
struct wl_surface* surface;
struct Win32SurfaceCreateInfoKHR
{
Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 )
- : sType( StructureType::eWin32SurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, hinstance( hinstance_ )
, hwnd( hwnd_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Win32SurfaceCreateFlagsKHR flags;
HINSTANCE hinstance;
HWND hwnd;
struct XlibSurfaceCreateInfoKHR
{
XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 )
- : sType( StructureType::eXlibSurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, dpy( dpy_ )
, window( window_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
XlibSurfaceCreateFlagsKHR flags;
Display* dpy;
Window window;
struct XcbSurfaceCreateInfoKHR
{
XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 )
- : sType( StructureType::eXcbSurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, connection( connection_ )
, window( window_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
XcbSurfaceCreateFlagsKHR flags;
xcb_connection_t* connection;
xcb_window_t window;
struct DebugMarkerMarkerInfoEXT
{
DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
- : sType( StructureType::eDebugMarkerMarkerInfoEXT )
- , pNext( nullptr )
- , pMarkerName( pMarkerName_ )
+ : pMarkerName( pMarkerName_ )
{
memcpy( &color, color_.data(), 4 * sizeof( float ) );
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
const char* pMarkerName;
float color[4];
};
struct DedicatedAllocationImageCreateInfoNV
{
DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
- : sType( StructureType::eDedicatedAllocationImageCreateInfoNV )
- , pNext( nullptr )
- , dedicatedAllocation( dedicatedAllocation_ )
+ : dedicatedAllocation( dedicatedAllocation_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Bool32 dedicatedAllocation;
};
static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
struct DedicatedAllocationBufferCreateInfoNV
{
DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
- : sType( StructureType::eDedicatedAllocationBufferCreateInfoNV )
- , pNext( nullptr )
- , dedicatedAllocation( dedicatedAllocation_ )
+ : dedicatedAllocation( dedicatedAllocation_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Bool32 dedicatedAllocation;
};
static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
struct DedicatedAllocationMemoryAllocateInfoNV
{
DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), Buffer buffer_ = Buffer() )
- : sType( StructureType::eDedicatedAllocationMemoryAllocateInfoNV )
- , pNext( nullptr )
- , image( image_ )
+ : image( image_ )
, buffer( buffer_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Image image;
Buffer buffer;
};
struct ExportMemoryWin32HandleInfoNV
{
ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 )
- : sType( StructureType::eExportMemoryWin32HandleInfoNV )
- , pNext( nullptr )
- , pAttributes( pAttributes_ )
+ : pAttributes( pAttributes_ )
, dwAccess( dwAccess_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess;
};
struct Win32KeyedMutexAcquireReleaseInfoNV
{
Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
- : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoNV )
- , pNext( nullptr )
- , acquireCount( acquireCount_ )
+ : acquireCount( acquireCount_ )
, pAcquireSyncs( pAcquireSyncs_ )
, pAcquireKeys( pAcquireKeys_ )
, pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t acquireCount;
const DeviceMemory* pAcquireSyncs;
const uint64_t* pAcquireKeys;
struct DeviceGeneratedCommandsFeaturesNVX
{
DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
- : sType( StructureType::eDeviceGeneratedCommandsFeaturesNVX )
- , pNext( nullptr )
- , computeBindingPointSupport( computeBindingPointSupport_ )
+ : computeBindingPointSupport( computeBindingPointSupport_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Bool32 computeBindingPointSupport;
};
static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
struct DeviceGeneratedCommandsLimitsNVX
{
DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
- : sType( StructureType::eDeviceGeneratedCommandsLimitsNVX )
- , pNext( nullptr )
- , maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
+ : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
, maxObjectEntryCounts( maxObjectEntryCounts_ )
, minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
, minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t maxIndirectCommandsLayoutTokenCount;
uint32_t maxObjectEntryCounts;
uint32_t minSequenceCountBufferOffsetAlignment;
struct CmdReserveSpaceForCommandsInfoNVX
{
CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 )
- : sType( StructureType::eCmdReserveSpaceForCommandsInfoNVX )
- , pNext( nullptr )
- , objectTable( objectTable_ )
+ : objectTable( objectTable_ )
, indirectCommandsLayout( indirectCommandsLayout_ )
, maxSequencesCount( maxSequencesCount_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ObjectTableNVX objectTable;
IndirectCommandsLayoutNVX indirectCommandsLayout;
uint32_t maxSequencesCount;
struct PhysicalDeviceFeatures2KHR
{
PhysicalDeviceFeatures2KHR( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
- : sType( StructureType::ePhysicalDeviceFeatures2KHR )
- , pNext( nullptr )
- , features( features_ )
+ : features( features_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceFeatures2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
PhysicalDeviceFeatures features;
};
static_assert( sizeof( PhysicalDeviceFeatures2KHR ) == sizeof( VkPhysicalDeviceFeatures2KHR ), "struct and wrapper have different size!" );
struct PhysicalDevicePushDescriptorPropertiesKHR
{
PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
- : sType( StructureType::ePhysicalDevicePushDescriptorPropertiesKHR )
- , pNext( nullptr )
- , maxPushDescriptors( maxPushDescriptors_ )
+ : maxPushDescriptors( maxPushDescriptors_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t maxPushDescriptors;
};
static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
struct PresentRegionsKHR
{
PresentRegionsKHR( uint32_t swapchainCount_ = 0, const PresentRegionKHR* pRegions_ = nullptr )
- : sType( StructureType::ePresentRegionsKHR )
- , pNext( nullptr )
- , swapchainCount( swapchainCount_ )
+ : swapchainCount( swapchainCount_ )
, pRegions( pRegions_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePresentRegionsKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t swapchainCount;
const PresentRegionKHR* pRegions;
};
struct PhysicalDeviceVariablePointerFeaturesKHR
{
PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 )
- : sType( StructureType::ePhysicalDeviceVariablePointerFeaturesKHR )
- , pNext( nullptr )
- , variablePointersStorageBuffer( variablePointersStorageBuffer_ )
+ : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
, variablePointers( variablePointers_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeaturesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 variablePointersStorageBuffer;
Bool32 variablePointers;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceIdPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
uint8_t deviceUUID[VK_UUID_SIZE];
uint8_t driverUUID[VK_UUID_SIZE];
uint8_t deviceLUID[VK_LUID_SIZE_KHR];
struct ExportMemoryWin32HandleInfoKHR
{
ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
- : sType( StructureType::eExportMemoryWin32HandleInfoKHR )
- , pNext( nullptr )
- , pAttributes( pAttributes_ )
+ : pAttributes( pAttributes_ )
, dwAccess( dwAccess_ )
, name( name_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess;
LPCWSTR name;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t memoryTypeBits;
};
static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryFdPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t memoryTypeBits;
};
static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
struct Win32KeyedMutexAcquireReleaseInfoKHR
{
Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
- : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR )
- , pNext( nullptr )
- , acquireCount( acquireCount_ )
+ : acquireCount( acquireCount_ )
, pAcquireSyncs( pAcquireSyncs_ )
, pAcquireKeys( pAcquireKeys_ )
, pAcquireTimeouts( pAcquireTimeouts_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t acquireCount;
const DeviceMemory* pAcquireSyncs;
const uint64_t* pAcquireKeys;
struct ExportSemaphoreWin32HandleInfoKHR
{
ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
- : sType( StructureType::eExportSemaphoreWin32HandleInfoKHR )
- , pNext( nullptr )
- , pAttributes( pAttributes_ )
+ : pAttributes( pAttributes_ )
, dwAccess( dwAccess_ )
, name( name_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess;
LPCWSTR name;
struct D3D12FenceSubmitInfoKHR
{
D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr )
- : sType( StructureType::eD3D12FenceSubmitInfoKHR )
- , pNext( nullptr )
- , waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
+ : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
, pWaitSemaphoreValues( pWaitSemaphoreValues_ )
, signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
, pSignalSemaphoreValues( pSignalSemaphoreValues_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t waitSemaphoreValuesCount;
const uint64_t* pWaitSemaphoreValues;
uint32_t signalSemaphoreValuesCount;
struct ExportFenceWin32HandleInfoKHR
{
ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
- : sType( StructureType::eExportFenceWin32HandleInfoKHR )
- , pNext( nullptr )
- , pAttributes( pAttributes_ )
+ : pAttributes( pAttributes_ )
, dwAccess( dwAccess_ )
, name( name_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
const SECURITY_ATTRIBUTES* pAttributes;
DWORD dwAccess;
LPCWSTR name;
struct PhysicalDeviceMultiviewFeaturesKHX
{
PhysicalDeviceMultiviewFeaturesKHX( Bool32 multiview_ = 0, Bool32 multiviewGeometryShader_ = 0, Bool32 multiviewTessellationShader_ = 0 )
- : sType( StructureType::ePhysicalDeviceMultiviewFeaturesKHX )
- , pNext( nullptr )
- , multiview( multiview_ )
+ : multiview( multiview_ )
, multiviewGeometryShader( multiviewGeometryShader_ )
, multiviewTessellationShader( multiviewTessellationShader_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceMultiviewFeaturesKHX;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 multiview;
Bool32 multiviewGeometryShader;
Bool32 multiviewTessellationShader;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceMultiviewPropertiesKHX;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t maxMultiviewViewCount;
uint32_t maxMultiviewInstanceIndex;
};
struct RenderPassMultiviewCreateInfoKHX
{
RenderPassMultiviewCreateInfoKHX( uint32_t subpassCount_ = 0, const uint32_t* pViewMasks_ = nullptr, uint32_t dependencyCount_ = 0, const int32_t* pViewOffsets_ = nullptr, uint32_t correlationMaskCount_ = 0, const uint32_t* pCorrelationMasks_ = nullptr )
- : sType( StructureType::eRenderPassMultiviewCreateInfoKHX )
- , pNext( nullptr )
- , subpassCount( subpassCount_ )
+ : subpassCount( subpassCount_ )
, pViewMasks( pViewMasks_ )
, dependencyCount( dependencyCount_ )
, pViewOffsets( pViewOffsets_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eRenderPassMultiviewCreateInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t subpassCount;
const uint32_t* pViewMasks;
uint32_t dependencyCount;
struct BindBufferMemoryInfoKHR
{
BindBufferMemoryInfoKHR( Buffer buffer_ = Buffer(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 )
- : sType( StructureType::eBindBufferMemoryInfoKHR )
- , pNext( nullptr )
- , buffer( buffer_ )
+ : buffer( buffer_ )
, memory( memory_ )
, memoryOffset( memoryOffset_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindBufferMemoryInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Buffer buffer;
DeviceMemory memory;
DeviceSize memoryOffset;
struct BindBufferMemoryDeviceGroupInfoKHX
{
BindBufferMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr )
- : sType( StructureType::eBindBufferMemoryDeviceGroupInfoKHX )
- , pNext( nullptr )
- , deviceIndexCount( deviceIndexCount_ )
+ : deviceIndexCount( deviceIndexCount_ )
, pDeviceIndices( pDeviceIndices_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices;
};
struct BindImageMemoryInfoKHR
{
BindImageMemoryInfoKHR( Image image_ = Image(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 )
- : sType( StructureType::eBindImageMemoryInfoKHR )
- , pNext( nullptr )
- , image( image_ )
+ : image( image_ )
, memory( memory_ )
, memoryOffset( memoryOffset_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindImageMemoryInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Image image;
DeviceMemory memory;
DeviceSize memoryOffset;
struct BindImageMemoryDeviceGroupInfoKHX
{
BindImageMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t SFRRectCount_ = 0, const Rect2D* pSFRRects_ = nullptr )
- : sType( StructureType::eBindImageMemoryDeviceGroupInfoKHX )
- , pNext( nullptr )
- , deviceIndexCount( deviceIndexCount_ )
+ : deviceIndexCount( deviceIndexCount_ )
, pDeviceIndices( pDeviceIndices_ )
, SFRRectCount( SFRRectCount_ )
, pSFRRects( pSFRRects_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t deviceIndexCount;
const uint32_t* pDeviceIndices;
uint32_t SFRRectCount;
struct DeviceGroupRenderPassBeginInfoKHX
{
DeviceGroupRenderPassBeginInfoKHX( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const Rect2D* pDeviceRenderAreas_ = nullptr )
- : sType( StructureType::eDeviceGroupRenderPassBeginInfoKHX )
- , pNext( nullptr )
- , deviceMask( deviceMask_ )
+ : deviceMask( deviceMask_ )
, deviceRenderAreaCount( deviceRenderAreaCount_ )
, pDeviceRenderAreas( pDeviceRenderAreas_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t deviceMask;
uint32_t deviceRenderAreaCount;
const Rect2D* pDeviceRenderAreas;
struct DeviceGroupCommandBufferBeginInfoKHX
{
DeviceGroupCommandBufferBeginInfoKHX( uint32_t deviceMask_ = 0 )
- : sType( StructureType::eDeviceGroupCommandBufferBeginInfoKHX )
- , pNext( nullptr )
- , deviceMask( deviceMask_ )
+ : deviceMask( deviceMask_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t deviceMask;
};
static_assert( sizeof( DeviceGroupCommandBufferBeginInfoKHX ) == sizeof( VkDeviceGroupCommandBufferBeginInfoKHX ), "struct and wrapper have different size!" );
struct DeviceGroupSubmitInfoKHX
{
DeviceGroupSubmitInfoKHX( uint32_t waitSemaphoreCount_ = 0, const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, uint32_t commandBufferCount_ = 0, const uint32_t* pCommandBufferDeviceMasks_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
- : sType( StructureType::eDeviceGroupSubmitInfoKHX )
- , pNext( nullptr )
- , waitSemaphoreCount( waitSemaphoreCount_ )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
, pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
, commandBufferCount( commandBufferCount_ )
, pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupSubmitInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t waitSemaphoreCount;
const uint32_t* pWaitSemaphoreDeviceIndices;
uint32_t commandBufferCount;
struct DeviceGroupBindSparseInfoKHX
{
DeviceGroupBindSparseInfoKHX( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 )
- : sType( StructureType::eDeviceGroupBindSparseInfoKHX )
- , pNext( nullptr )
- , resourceDeviceIndex( resourceDeviceIndex_ )
+ : resourceDeviceIndex( resourceDeviceIndex_ )
, memoryDeviceIndex( memoryDeviceIndex_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupBindSparseInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t resourceDeviceIndex;
uint32_t memoryDeviceIndex;
};
struct ImageSwapchainCreateInfoKHX
{
ImageSwapchainCreateInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR() )
- : sType( StructureType::eImageSwapchainCreateInfoKHX )
- , pNext( nullptr )
- , swapchain( swapchain_ )
+ : swapchain( swapchain_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageSwapchainCreateInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SwapchainKHR swapchain;
};
static_assert( sizeof( ImageSwapchainCreateInfoKHX ) == sizeof( VkImageSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
struct BindImageMemorySwapchainInfoKHX
{
BindImageMemorySwapchainInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint32_t imageIndex_ = 0 )
- : sType( StructureType::eBindImageMemorySwapchainInfoKHX )
- , pNext( nullptr )
- , swapchain( swapchain_ )
+ : swapchain( swapchain_ )
, imageIndex( imageIndex_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SwapchainKHR swapchain;
uint32_t imageIndex;
};
struct AcquireNextImageInfoKHX
{
AcquireNextImageInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint64_t timeout_ = 0, Semaphore semaphore_ = Semaphore(), Fence fence_ = Fence(), uint32_t deviceMask_ = 0 )
- : sType( StructureType::eAcquireNextImageInfoKHX )
- , pNext( nullptr )
- , swapchain( swapchain_ )
+ : swapchain( swapchain_ )
, timeout( timeout_ )
, semaphore( semaphore_ )
, fence( fence_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eAcquireNextImageInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SwapchainKHR swapchain;
uint64_t timeout;
Semaphore semaphore;
struct HdrMetadataEXT
{
HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(), XYColorEXT displayPrimaryGreen_ = XYColorEXT(), XYColorEXT displayPrimaryBlue_ = XYColorEXT(), XYColorEXT whitePoint_ = XYColorEXT(), float maxLuminance_ = 0, float minLuminance_ = 0, float maxContentLightLevel_ = 0, float maxFrameAverageLightLevel_ = 0 )
- : sType( StructureType::eHdrMetadataEXT )
- , pNext( nullptr )
- , displayPrimaryRed( displayPrimaryRed_ )
+ : displayPrimaryRed( displayPrimaryRed_ )
, displayPrimaryGreen( displayPrimaryGreen_ )
, displayPrimaryBlue( displayPrimaryBlue_ )
, whitePoint( whitePoint_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eHdrMetadataEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
XYColorEXT displayPrimaryRed;
XYColorEXT displayPrimaryGreen;
XYColorEXT displayPrimaryBlue;
struct PresentTimesInfoGOOGLE
{
PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const PresentTimeGOOGLE* pTimes_ = nullptr )
- : sType( StructureType::ePresentTimesInfoGOOGLE )
- , pNext( nullptr )
- , swapchainCount( swapchainCount_ )
+ : swapchainCount( swapchainCount_ )
, pTimes( pTimes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t swapchainCount;
const PresentTimeGOOGLE* pTimes;
};
struct IOSSurfaceCreateInfoMVK
{
IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
- : sType( StructureType::eIOSSurfaceCreateInfoMVK )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, pView( pView_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
public:
- const void* pNext;
+ const void* pNext = nullptr;
IOSSurfaceCreateFlagsMVK flags;
const void* pView;
};
struct MacOSSurfaceCreateInfoMVK
{
MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
- : sType( StructureType::eMacOSSurfaceCreateInfoMVK )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, pView( pView_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
public:
- const void* pNext;
+ const void* pNext = nullptr;
MacOSSurfaceCreateFlagsMVK flags;
const void* pView;
};
struct PipelineViewportWScalingStateCreateInfoNV
{
PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const ViewportWScalingNV* pViewportWScalings_ = nullptr )
- : sType( StructureType::ePipelineViewportWScalingStateCreateInfoNV )
- , pNext( nullptr )
- , viewportWScalingEnable( viewportWScalingEnable_ )
+ : viewportWScalingEnable( viewportWScalingEnable_ )
, viewportCount( viewportCount_ )
, pViewportWScalings( pViewportWScalings_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Bool32 viewportWScalingEnable;
uint32_t viewportCount;
const ViewportWScalingNV* pViewportWScalings;
struct PhysicalDeviceDiscardRectanglePropertiesEXT
{
PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
- : sType( StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT )
- , pNext( nullptr )
- , maxDiscardRectangles( maxDiscardRectangles_ )
+ : maxDiscardRectangles( maxDiscardRectangles_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t maxDiscardRectangles;
};
static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 perViewPositionAllComponents;
};
static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
struct PhysicalDeviceSurfaceInfo2KHR
{
PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
- : sType( StructureType::ePhysicalDeviceSurfaceInfo2KHR )
- , pNext( nullptr )
- , surface( surface_ )
+ : surface( surface_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SurfaceKHR surface;
};
static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
struct PhysicalDevice16BitStorageFeaturesKHR
{
PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 )
- : sType( StructureType::ePhysicalDevice16BitStorageFeaturesKHR )
- , pNext( nullptr )
- , storageBuffer16BitAccess( storageBuffer16BitAccess_ )
+ : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
, uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
, storagePushConstant16( storagePushConstant16_ )
, storageInputOutput16( storageInputOutput16_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDevice16BitStorageFeaturesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 storageBuffer16BitAccess;
Bool32 uniformAndStorageBuffer16BitAccess;
Bool32 storagePushConstant16;
struct BufferMemoryRequirementsInfo2KHR
{
BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() )
- : sType( StructureType::eBufferMemoryRequirementsInfo2KHR )
- , pNext( nullptr )
- , buffer( buffer_ )
+ : buffer( buffer_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBufferMemoryRequirementsInfo2KHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Buffer buffer;
};
static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
struct ImageMemoryRequirementsInfo2KHR
{
ImageMemoryRequirementsInfo2KHR( Image image_ = Image() )
- : sType( StructureType::eImageMemoryRequirementsInfo2KHR )
- , pNext( nullptr )
- , image( image_ )
+ : image( image_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageMemoryRequirementsInfo2KHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Image image;
};
static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
struct ImageSparseMemoryRequirementsInfo2KHR
{
ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() )
- : sType( StructureType::eImageSparseMemoryRequirementsInfo2KHR )
- , pNext( nullptr )
- , image( image_ )
+ : image( image_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2KHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Image image;
};
static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryRequirements2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
MemoryRequirements memoryRequirements;
};
static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryDedicatedRequirementsKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 prefersDedicatedAllocation;
Bool32 requiresDedicatedAllocation;
};
struct MemoryDedicatedAllocateInfoKHR
{
MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() )
- : sType( StructureType::eMemoryDedicatedAllocateInfoKHR )
- , pNext( nullptr )
- , image( image_ )
+ : image( image_ )
, buffer( buffer_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryDedicatedAllocateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Image image;
Buffer buffer;
};
struct SamplerYcbcrConversionInfoKHR
{
SamplerYcbcrConversionInfoKHR( SamplerYcbcrConversionKHR conversion_ = SamplerYcbcrConversionKHR() )
- : sType( StructureType::eSamplerYcbcrConversionInfoKHR )
- , pNext( nullptr )
- , conversion( conversion_ )
+ : conversion( conversion_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSamplerYcbcrConversionInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SamplerYcbcrConversionKHR conversion;
};
static_assert( sizeof( SamplerYcbcrConversionInfoKHR ) == sizeof( VkSamplerYcbcrConversionInfoKHR ), "struct and wrapper have different size!" );
struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR
{
PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( Bool32 samplerYcbcrConversion_ = 0 )
- : sType( StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR )
- , pNext( nullptr )
- , samplerYcbcrConversion( samplerYcbcrConversion_ )
+ : samplerYcbcrConversion( samplerYcbcrConversion_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 samplerYcbcrConversion;
};
static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t combinedImageSamplerDescriptorCount;
};
static_assert( sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) == sizeof( VkSamplerYcbcrConversionImageFormatPropertiesKHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 supportsTextureGatherLODBiasAMD;
};
static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
struct PipelineCoverageToColorStateCreateInfoNV
{
PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 )
- : sType( StructureType::ePipelineCoverageToColorStateCreateInfoNV )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, coverageToColorEnable( coverageToColorEnable_ )
, coverageToColorLocation( coverageToColorLocation_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineCoverageToColorStateCreateFlagsNV flags;
Bool32 coverageToColorEnable;
uint32_t coverageToColorLocation;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 filterMinmaxSingleComponentFormats;
Bool32 filterMinmaxImageComponentMapping;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMultisamplePropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
Extent2D maxSampleLocationGridSize;
};
static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
{
PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
- : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT )
- , pNext( nullptr )
- , advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
+ : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
Bool32 advancedBlendCoherentOperations;
};
static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t advancedBlendMaxColorAttachments;
Bool32 advancedBlendIndependentBlend;
Bool32 advancedBlendNonPremultipliedSrcColor;
struct ImageFormatListCreateInfoKHR
{
ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const Format* pViewFormats_ = nullptr )
- : sType( StructureType::eImageFormatListCreateInfoKHR )
- , pNext( nullptr )
- , viewFormatCount( viewFormatCount_ )
+ : viewFormatCount( viewFormatCount_ )
, pViewFormats( pViewFormats_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t viewFormatCount;
const Format* pViewFormats;
};
struct ValidationCacheCreateInfoEXT
{
ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
- : sType( StructureType::eValidationCacheCreateInfoEXT )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, initialDataSize( initialDataSize_ )
, pInitialData( pInitialData_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ValidationCacheCreateFlagsEXT flags;
size_t initialDataSize;
const void* pInitialData;
struct ShaderModuleValidationCacheCreateInfoEXT
{
ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
- : sType( StructureType::eShaderModuleValidationCacheCreateInfoEXT )
- , pNext( nullptr )
- , validationCache( validationCache_ )
+ : validationCache( validationCache_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ValidationCacheEXT validationCache;
};
static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
struct MemoryHostPointerPropertiesEXT
{
MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
- : sType( StructureType::eMemoryHostPointerPropertiesEXT )
- , pNext( nullptr )
- , memoryTypeBits( memoryTypeBits_ )
+ : memoryTypeBits( memoryTypeBits_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t memoryTypeBits;
};
static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
struct PhysicalDeviceExternalMemoryHostPropertiesEXT
{
PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
- : sType( StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT )
- , pNext( nullptr )
- , minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
+ : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
DeviceSize minImportedHostPointerAlignment;
};
static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
+ struct PhysicalDeviceConservativeRasterizationPropertiesEXT
+ {
+ PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0, float maxExtraPrimitiveOverestimationSize_ = 0, float extraPrimitiveOverestimationSizeGranularity_ = 0, Bool32 primitiveUnderestimation_ = 0, Bool32 conservativePointAndLineRasterization_ = 0, Bool32 degenerateTrianglesRasterized_ = 0, Bool32 degenerateLinesRasterized_ = 0, Bool32 fullyCoveredFragmentShaderInputVariable_ = 0, Bool32 conservativeRasterizationPostDepthCoverage_ = 0 )
+ : primitiveOverestimationSize( primitiveOverestimationSize_ )
+ , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ )
+ , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ )
+ , primitiveUnderestimation( primitiveUnderestimation_ )
+ , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ )
+ , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ )
+ , degenerateLinesRasterized( degenerateLinesRasterized_ )
+ , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ )
+ , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
+ {
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) );
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) );
+ return *this;
+ }
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setPNext( void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveOverestimationSize( float primitiveOverestimationSize_ )
+ {
+ primitiveOverestimationSize = primitiveOverestimationSize_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ )
+ {
+ maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ )
+ {
+ extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ )
+ {
+ primitiveUnderestimation = primitiveUnderestimation_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ )
+ {
+ conservativePointAndLineRasterization = conservativePointAndLineRasterization_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ )
+ {
+ degenerateTrianglesRasterized = degenerateTrianglesRasterized_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ )
+ {
+ degenerateLinesRasterized = degenerateLinesRasterized_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ )
+ {
+ fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_;
+ return *this;
+ }
+
+ PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ )
+ {
+ conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_;
+ return *this;
+ }
+
+ operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const
+ {
+ return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+ }
+
+ bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize )
+ && ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize )
+ && ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity )
+ && ( primitiveUnderestimation == rhs.primitiveUnderestimation )
+ && ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization )
+ && ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized )
+ && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized )
+ && ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable )
+ && ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage );
+ }
+
+ bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
+
+ public:
+ void* pNext = nullptr;
+ float primitiveOverestimationSize;
+ float maxExtraPrimitiveOverestimationSize;
+ float extraPrimitiveOverestimationSizeGranularity;
+ Bool32 primitiveUnderestimation;
+ Bool32 conservativePointAndLineRasterization;
+ Bool32 degenerateTrianglesRasterized;
+ Bool32 degenerateLinesRasterized;
+ Bool32 fullyCoveredFragmentShaderInputVariable;
+ Bool32 conservativeRasterizationPostDepthCoverage;
+ };
+ static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
+
enum class SubpassContents
{
eInline = VK_SUBPASS_CONTENTS_INLINE,
struct PresentInfoKHR
{
PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr )
- : sType( StructureType::ePresentInfoKHR )
- , pNext( nullptr )
- , waitSemaphoreCount( waitSemaphoreCount_ )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
, pWaitSemaphores( pWaitSemaphores_ )
, swapchainCount( swapchainCount_ )
, pSwapchains( pSwapchains_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePresentInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t waitSemaphoreCount;
const Semaphore* pWaitSemaphores;
uint32_t swapchainCount;
struct PipelineDynamicStateCreateInfo
{
PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr )
- : sType( StructureType::ePipelineDynamicStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, dynamicStateCount( dynamicStateCount_ )
, pDynamicStates( pDynamicStates_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineDynamicStateCreateFlags flags;
uint32_t dynamicStateCount;
const DynamicState* pDynamicStates;
struct DescriptorUpdateTemplateCreateInfoKHR
{
DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 )
- : sType( StructureType::eDescriptorUpdateTemplateCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
, pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
, templateType( templateType_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfoKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
DescriptorUpdateTemplateCreateFlagsKHR flags;
uint32_t descriptorUpdateEntryCount;
const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eQueueFamilyProperties2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
QueueFamilyProperties queueFamilyProperties;
};
static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
PhysicalDeviceMemoryProperties memoryProperties;
};
static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" );
struct MemoryBarrier
{
MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() )
- : sType( StructureType::eMemoryBarrier )
- , pNext( nullptr )
- , srcAccessMask( srcAccessMask_ )
+ : srcAccessMask( srcAccessMask_ )
, dstAccessMask( dstAccessMask_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryBarrier;
public:
- const void* pNext;
+ const void* pNext = nullptr;
AccessFlags srcAccessMask;
AccessFlags dstAccessMask;
};
struct BufferMemoryBarrier
{
BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
- : sType( StructureType::eBufferMemoryBarrier )
- , pNext( nullptr )
- , srcAccessMask( srcAccessMask_ )
+ : srcAccessMask( srcAccessMask_ )
, dstAccessMask( dstAccessMask_ )
, srcQueueFamilyIndex( srcQueueFamilyIndex_ )
, dstQueueFamilyIndex( dstQueueFamilyIndex_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBufferMemoryBarrier;
public:
- const void* pNext;
+ const void* pNext = nullptr;
AccessFlags srcAccessMask;
AccessFlags dstAccessMask;
uint32_t srcQueueFamilyIndex;
struct BufferCreateInfo
{
BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr )
- : sType( StructureType::eBufferCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, size( size_ )
, usage( usage_ )
, sharingMode( sharingMode_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBufferCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
BufferCreateFlags flags;
DeviceSize size;
BufferUsageFlags usage;
struct PipelineShaderStageCreateInfo
{
PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr )
- : sType( StructureType::ePipelineShaderStageCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, stage( stage_ )
, module( module_ )
, pName( pName_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineShaderStageCreateFlags flags;
ShaderStageFlagBits stage;
ShaderModule module;
struct PipelineLayoutCreateInfo
{
PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr )
- : sType( StructureType::ePipelineLayoutCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, setLayoutCount( setLayoutCount_ )
, pSetLayouts( pSetLayouts_ )
, pushConstantRangeCount( pushConstantRangeCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineLayoutCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineLayoutCreateFlags flags;
uint32_t setLayoutCount;
const DescriptorSetLayout* pSetLayouts;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
ImageUsageFlags sharedPresentSupportedUsageFlags;
};
static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
struct ImageViewUsageCreateInfoKHR
{
ImageViewUsageCreateInfoKHR( ImageUsageFlags usage_ = ImageUsageFlags() )
- : sType( StructureType::eImageViewUsageCreateInfoKHR )
- , pNext( nullptr )
- , usage( usage_ )
+ : usage( usage_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageViewUsageCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ImageUsageFlags usage;
};
static_assert( sizeof( ImageViewUsageCreateInfoKHR ) == sizeof( VkImageViewUsageCreateInfoKHR ), "struct and wrapper have different size!" );
struct PhysicalDeviceImageFormatInfo2KHR
{
PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() )
- : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHR )
- , pNext( nullptr )
- , format( format_ )
+ : format( format_ )
, type( type_ )
, tiling( tiling_ )
, usage( usage_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2KHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Format format;
ImageType type;
ImageTiling tiling;
struct ComputePipelineCreateInfo
{
ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
- : sType( StructureType::eComputePipelineCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, stage( stage_ )
, layout( layout_ )
, basePipelineHandle( basePipelineHandle_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eComputePipelineCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineCreateFlags flags;
PipelineShaderStageCreateInfo stage;
PipelineLayout layout;
struct PipelineColorBlendStateCreateInfo
{
PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
- : sType( StructureType::ePipelineColorBlendStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, logicOpEnable( logicOpEnable_ )
, logicOp( logicOp_ )
, attachmentCount( attachmentCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineColorBlendStateCreateFlags flags;
Bool32 logicOpEnable;
LogicOp logicOp;
struct FenceCreateInfo
{
FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
- : sType( StructureType::eFenceCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eFenceCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
FenceCreateFlags flags;
};
static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eFormatProperties2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
FormatProperties formatProperties;
};
static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" );
struct CommandBufferInheritanceInfo
{
CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : sType( StructureType::eCommandBufferInheritanceInfo )
- , pNext( nullptr )
- , renderPass( renderPass_ )
+ : renderPass( renderPass_ )
, subpass( subpass_ )
, framebuffer( framebuffer_ )
, occlusionQueryEnable( occlusionQueryEnable_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCommandBufferInheritanceInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
RenderPass renderPass;
uint32_t subpass;
Framebuffer framebuffer;
struct CommandBufferBeginInfo
{
CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
- : sType( StructureType::eCommandBufferBeginInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, pInheritanceInfo( pInheritanceInfo_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCommandBufferBeginInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
CommandBufferUsageFlags flags;
const CommandBufferInheritanceInfo* pInheritanceInfo;
};
struct QueryPoolCreateInfo
{
QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
- : sType( StructureType::eQueryPoolCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, queryType( queryType_ )
, queryCount( queryCount_ )
, pipelineStatistics( pipelineStatistics_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eQueryPoolCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
QueryPoolCreateFlags flags;
QueryType queryType;
uint32_t queryCount;
struct ImageMemoryBarrier
{
ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
- : sType( StructureType::eImageMemoryBarrier )
- , pNext( nullptr )
- , srcAccessMask( srcAccessMask_ )
+ : srcAccessMask( srcAccessMask_ )
, dstAccessMask( dstAccessMask_ )
, oldLayout( oldLayout_ )
, newLayout( newLayout_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageMemoryBarrier;
public:
- const void* pNext;
+ const void* pNext = nullptr;
AccessFlags srcAccessMask;
AccessFlags dstAccessMask;
ImageLayout oldLayout;
struct ImageViewCreateInfo
{
ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
- : sType( StructureType::eImageViewCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, image( image_ )
, viewType( viewType_ )
, format( format_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageViewCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ImageViewCreateFlags flags;
Image image;
ImageViewType viewType;
struct RenderPassInputAttachmentAspectCreateInfoKHR
{
RenderPassInputAttachmentAspectCreateInfoKHR( uint32_t aspectReferenceCount_ = 0, const InputAttachmentAspectReferenceKHR* pAspectReferences_ = nullptr )
- : sType( StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR )
- , pNext( nullptr )
- , aspectReferenceCount( aspectReferenceCount_ )
+ : aspectReferenceCount( aspectReferenceCount_ )
, pAspectReferences( pAspectReferences_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t aspectReferenceCount;
const InputAttachmentAspectReferenceKHR* pAspectReferences;
};
struct BindImagePlaneMemoryInfoKHR
{
BindImagePlaneMemoryInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
- : sType( StructureType::eBindImagePlaneMemoryInfoKHR )
- , pNext( nullptr )
- , planeAspect( planeAspect_ )
+ : planeAspect( planeAspect_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindImagePlaneMemoryInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ImageAspectFlagBits planeAspect;
};
static_assert( sizeof( BindImagePlaneMemoryInfoKHR ) == sizeof( VkBindImagePlaneMemoryInfoKHR ), "struct and wrapper have different size!" );
struct ImagePlaneMemoryRequirementsInfoKHR
{
ImagePlaneMemoryRequirementsInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
- : sType( StructureType::eImagePlaneMemoryRequirementsInfoKHR )
- , pNext( nullptr )
- , planeAspect( planeAspect_ )
+ : planeAspect( planeAspect_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ImageAspectFlagBits planeAspect;
};
static_assert( sizeof( ImagePlaneMemoryRequirementsInfoKHR ) == sizeof( VkImagePlaneMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSparseImageFormatProperties2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
SparseImageFormatProperties properties;
};
static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSparseImageMemoryRequirements2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
SparseImageMemoryRequirements memoryRequirements;
};
static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" );
struct BindSparseInfo
{
BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
- : sType( StructureType::eBindSparseInfo )
- , pNext( nullptr )
- , waitSemaphoreCount( waitSemaphoreCount_ )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
, pWaitSemaphores( pWaitSemaphores_ )
, bufferBindCount( bufferBindCount_ )
, pBufferBinds( pBufferBinds_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eBindSparseInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t waitSemaphoreCount;
const Semaphore* pWaitSemaphores;
uint32_t bufferBindCount;
struct CommandPoolCreateInfo
{
CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 )
- : sType( StructureType::eCommandPoolCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, queueFamilyIndex( queueFamilyIndex_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCommandPoolCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
CommandPoolCreateFlags flags;
uint32_t queueFamilyIndex;
};
struct ImageCreateInfo
{
ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined )
- : sType( StructureType::eImageCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, imageType( imageType_ )
, format( format_ )
, extent( extent_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ImageCreateFlags flags;
ImageType imageType;
Format format;
struct PipelineMultisampleStateCreateInfo
{
PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 )
- : sType( StructureType::ePipelineMultisampleStateCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, rasterizationSamples( rasterizationSamples_ )
, sampleShadingEnable( sampleShadingEnable_ )
, minSampleShading( minSampleShading_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineMultisampleStateCreateFlags flags;
SampleCountFlagBits rasterizationSamples;
Bool32 sampleShadingEnable;
struct GraphicsPipelineCreateInfo
{
GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
- : sType( StructureType::eGraphicsPipelineCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, stageCount( stageCount_ )
, pStages( pStages_ )
, pVertexInputState( pVertexInputState_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineCreateFlags flags;
uint32_t stageCount;
const PipelineShaderStageCreateInfo* pStages;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceProperties2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
PhysicalDeviceProperties properties;
};
static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImageFormatProperties2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
ImageFormatProperties imageFormatProperties;
};
static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" );
struct PhysicalDeviceSparseImageFormatInfo2KHR
{
PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal )
- : sType( StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR )
- , pNext( nullptr )
- , format( format_ )
+ : format( format_ )
, type( type_ )
, samples( samples_ )
, usage( usage_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Format format;
ImageType type;
SampleCountFlagBits samples;
struct SampleLocationsInfoEXT
{
SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, Extent2D sampleLocationGridSize_ = Extent2D(), uint32_t sampleLocationsCount_ = 0, const SampleLocationEXT* pSampleLocations_ = nullptr )
- : sType( StructureType::eSampleLocationsInfoEXT )
- , pNext( nullptr )
- , sampleLocationsPerPixel( sampleLocationsPerPixel_ )
+ : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
, sampleLocationGridSize( sampleLocationGridSize_ )
, sampleLocationsCount( sampleLocationsCount_ )
, pSampleLocations( pSampleLocations_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSampleLocationsInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SampleCountFlagBits sampleLocationsPerPixel;
Extent2D sampleLocationGridSize;
uint32_t sampleLocationsCount;
struct RenderPassSampleLocationsBeginInfoEXT
{
RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
- : sType( StructureType::eRenderPassSampleLocationsBeginInfoEXT )
- , pNext( nullptr )
- , attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
+ : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
, pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
, postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
, pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t attachmentInitialSampleLocationsCount;
const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
uint32_t postSubpassSampleLocationsCount;
struct PipelineSampleLocationsStateCreateInfoEXT
{
PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
- : sType( StructureType::ePipelineSampleLocationsStateCreateInfoEXT )
- , pNext( nullptr )
- , sampleLocationsEnable( sampleLocationsEnable_ )
+ : sampleLocationsEnable( sampleLocationsEnable_ )
, sampleLocationsInfo( sampleLocationsInfo_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Bool32 sampleLocationsEnable;
SampleLocationsInfoEXT sampleLocationsInfo;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
public:
- void* pNext;
+ void* pNext = nullptr;
SampleCountFlags sampleLocationSampleCounts;
Extent2D maxSampleLocationGridSize;
float sampleLocationCoordinateRange[2];
struct DescriptorPoolCreateInfo
{
DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr )
- : sType( StructureType::eDescriptorPoolCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, maxSets( maxSets_ )
, poolSizeCount( poolSizeCount_ )
, pPoolSizes( pPoolSizes_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDescriptorPoolCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DescriptorPoolCreateFlags flags;
uint32_t maxSets;
uint32_t poolSizeCount;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSurfaceFormat2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
SurfaceFormatKHR surfaceFormat;
};
static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
struct DisplaySurfaceCreateInfoKHR
{
DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() )
- : sType( StructureType::eDisplaySurfaceCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, displayMode( displayMode_ )
, planeIndex( planeIndex_ )
, planeStackIndex( planeStackIndex_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DisplaySurfaceCreateFlagsKHR flags;
DisplayModeKHR displayMode;
uint32_t planeIndex;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSurfaceCapabilities2KHR;
public:
- void* pNext;
+ void* pNext = nullptr;
SurfaceCapabilitiesKHR surfaceCapabilities;
};
static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
struct DebugReportCallbackCreateInfoEXT
{
DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr )
- : sType( StructureType::eDebugReportCallbackCreateInfoEXT )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, pfnCallback( pfnCallback_ )
, pUserData( pUserData_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DebugReportFlagsEXT flags;
PFN_vkDebugReportCallbackEXT pfnCallback;
void* pUserData;
struct DebugMarkerObjectNameInfoEXT
{
DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr )
- : sType( StructureType::eDebugMarkerObjectNameInfoEXT )
- , pNext( nullptr )
- , objectType( objectType_ )
+ : objectType( objectType_ )
, object( object_ )
, pObjectName( pObjectName_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DebugReportObjectTypeEXT objectType;
uint64_t object;
const char* pObjectName;
struct DebugMarkerObjectTagInfoEXT
{
DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr )
- : sType( StructureType::eDebugMarkerObjectTagInfoEXT )
- , pNext( nullptr )
- , objectType( objectType_ )
+ : objectType( objectType_ )
, object( object_ )
, tagName( tagName_ )
, tagSize( tagSize_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DebugReportObjectTypeEXT objectType;
uint64_t object;
uint64_t tagName;
struct PipelineRasterizationStateRasterizationOrderAMD
{
PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
- : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD )
- , pNext( nullptr )
- , rasterizationOrder( rasterizationOrder_ )
+ : rasterizationOrder( rasterizationOrder_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
public:
- const void* pNext;
+ const void* pNext = nullptr;
RasterizationOrderAMD rasterizationOrder;
};
static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
struct ExternalMemoryImageCreateInfoNV
{
ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : sType( StructureType::eExternalMemoryImageCreateInfoNV )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagsNV handleTypes;
};
static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
struct ExportMemoryAllocateInfoNV
{
ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
- : sType( StructureType::eExportMemoryAllocateInfoNV )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagsNV handleTypes;
};
static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
struct ImportMemoryWin32HandleInfoNV
{
ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
- : sType( StructureType::eImportMemoryWin32HandleInfoNV )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
, handle( handle_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagsNV handleType;
HANDLE handle;
};
struct ValidationFlagsEXT
{
ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
- : sType( StructureType::eValidationFlagsEXT )
- , pNext( nullptr )
- , disabledValidationCheckCount( disabledValidationCheckCount_ )
+ : disabledValidationCheckCount( disabledValidationCheckCount_ )
, pDisabledValidationChecks( pDisabledValidationChecks_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eValidationFlagsEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t disabledValidationCheckCount;
ValidationCheckEXT* pDisabledValidationChecks;
};
struct IndirectCommandsLayoutCreateInfoNVX
{
IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
- : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX )
- , pNext( nullptr )
- , pipelineBindPoint( pipelineBindPoint_ )
+ : pipelineBindPoint( pipelineBindPoint_ )
, flags( flags_ )
, tokenCount( tokenCount_ )
, pTokens( pTokens_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineBindPoint pipelineBindPoint;
IndirectCommandsLayoutUsageFlagsNVX flags;
uint32_t tokenCount;
struct ObjectTableCreateInfoNVX
{
ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, const uint32_t* pObjectEntryCounts_ = nullptr, const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, uint32_t maxUniformBuffersPerDescriptor_ = 0, uint32_t maxStorageBuffersPerDescriptor_ = 0, uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 )
- : sType( StructureType::eObjectTableCreateInfoNVX )
- , pNext( nullptr )
- , objectCount( objectCount_ )
+ : objectCount( objectCount_ )
, pObjectEntryTypes( pObjectEntryTypes_ )
, pObjectEntryCounts( pObjectEntryCounts_ )
, pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eObjectTableCreateInfoNVX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t objectCount;
const ObjectEntryTypeNVX* pObjectEntryTypes;
const uint32_t* pObjectEntryCounts;
struct DescriptorSetLayoutCreateInfo
{
DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr )
- : sType( StructureType::eDescriptorSetLayoutCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, bindingCount( bindingCount_ )
, pBindings( pBindings_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DescriptorSetLayoutCreateFlags flags;
uint32_t bindingCount;
const DescriptorSetLayoutBinding* pBindings;
struct PhysicalDeviceExternalImageFormatInfoKHR
{
PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHR )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
};
static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" );
struct PhysicalDeviceExternalBufferInfoKHR
{
PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, usage( usage_ )
, handleType( handleType_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
BufferCreateFlags flags;
BufferUsageFlags usage;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
struct ExternalMemoryImageCreateInfoKHR
{
ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
- : sType( StructureType::eExternalMemoryImageCreateInfoKHR )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalMemoryImageCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagsKHR handleTypes;
};
static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" );
struct ExternalMemoryBufferCreateInfoKHR
{
ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
- : sType( StructureType::eExternalMemoryBufferCreateInfoKHR )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalMemoryBufferCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagsKHR handleTypes;
};
static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" );
struct ExportMemoryAllocateInfoKHR
{
ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
- : sType( StructureType::eExportMemoryAllocateInfoKHR )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportMemoryAllocateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagsKHR handleTypes;
};
static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" );
struct ImportMemoryWin32HandleInfoKHR
{
ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
- : sType( StructureType::eImportMemoryWin32HandleInfoKHR )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
, handle( handle_ )
, name( name_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
HANDLE handle;
LPCWSTR name;
struct MemoryGetWin32HandleInfoKHR
{
MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::eMemoryGetWin32HandleInfoKHR )
- , pNext( nullptr )
- , memory( memory_ )
+ : memory( memory_ )
, handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceMemory memory;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
};
struct ImportMemoryFdInfoKHR
{
ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
- : sType( StructureType::eImportMemoryFdInfoKHR )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
, fd( fd_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportMemoryFdInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
int fd;
};
struct MemoryGetFdInfoKHR
{
MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::eMemoryGetFdInfoKHR )
- , pNext( nullptr )
- , memory( memory_ )
+ : memory( memory_ )
, handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryGetFdInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceMemory memory;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
};
struct ImportMemoryHostPointerInfoEXT
{
ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, void* pHostPointer_ = nullptr )
- : sType( StructureType::eImportMemoryHostPointerInfoEXT )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
, pHostPointer( pHostPointer_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalMemoryHandleTypeFlagBitsKHR handleType;
void* pHostPointer;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalImageFormatPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
ExternalMemoryPropertiesKHR externalMemoryProperties;
};
static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" );
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalBufferPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
ExternalMemoryPropertiesKHR externalMemoryProperties;
};
static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" );
struct PhysicalDeviceExternalSemaphoreInfoKHR
{
PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
};
static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" );
struct ExportSemaphoreCreateInfoKHR
{
ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() )
- : sType( StructureType::eExportSemaphoreCreateInfoKHR )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportSemaphoreCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalSemaphoreHandleTypeFlagsKHR handleTypes;
};
static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" );
struct SemaphoreGetWin32HandleInfoKHR
{
SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::eSemaphoreGetWin32HandleInfoKHR )
- , pNext( nullptr )
- , semaphore( semaphore_ )
+ : semaphore( semaphore_ )
, handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Semaphore semaphore;
ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
};
struct SemaphoreGetFdInfoKHR
{
SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::eSemaphoreGetFdInfoKHR )
- , pNext( nullptr )
- , semaphore( semaphore_ )
+ : semaphore( semaphore_ )
, handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Semaphore semaphore;
ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalSemaphorePropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes;
ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes;
ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures;
struct ImportSemaphoreWin32HandleInfoKHR
{
ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
- : sType( StructureType::eImportSemaphoreWin32HandleInfoKHR )
- , pNext( nullptr )
- , semaphore( semaphore_ )
+ : semaphore( semaphore_ )
, flags( flags_ )
, handleType( handleType_ )
, handle( handle_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Semaphore semaphore;
SemaphoreImportFlagsKHR flags;
ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
struct ImportSemaphoreFdInfoKHR
{
ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
- : sType( StructureType::eImportSemaphoreFdInfoKHR )
- , pNext( nullptr )
- , semaphore( semaphore_ )
+ : semaphore( semaphore_ )
, flags( flags_ )
, handleType( handleType_ )
, fd( fd_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Semaphore semaphore;
SemaphoreImportFlagsKHR flags;
ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
struct PhysicalDeviceExternalFenceInfoKHR
{
PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::ePhysicalDeviceExternalFenceInfoKHR )
- , pNext( nullptr )
- , handleType( handleType_ )
+ : handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalFenceHandleTypeFlagBitsKHR handleType;
};
static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" );
struct ExportFenceCreateInfoKHR
{
ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() )
- : sType( StructureType::eExportFenceCreateInfoKHR )
- , pNext( nullptr )
- , handleTypes( handleTypes_ )
+ : handleTypes( handleTypes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExportFenceCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ExternalFenceHandleTypeFlagsKHR handleTypes;
};
static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" );
struct FenceGetWin32HandleInfoKHR
{
FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::eFenceGetWin32HandleInfoKHR )
- , pNext( nullptr )
- , fence( fence_ )
+ : fence( fence_ )
, handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Fence fence;
ExternalFenceHandleTypeFlagBitsKHR handleType;
};
struct FenceGetFdInfoKHR
{
FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
- : sType( StructureType::eFenceGetFdInfoKHR )
- , pNext( nullptr )
- , fence( fence_ )
+ : fence( fence_ )
, handleType( handleType_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eFenceGetFdInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Fence fence;
ExternalFenceHandleTypeFlagBitsKHR handleType;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eExternalFencePropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes;
ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes;
ExternalFenceFeatureFlagsKHR externalFenceFeatures;
struct ImportFenceWin32HandleInfoKHR
{
ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
- : sType( StructureType::eImportFenceWin32HandleInfoKHR )
- , pNext( nullptr )
- , fence( fence_ )
+ : fence( fence_ )
, flags( flags_ )
, handleType( handleType_ )
, handle( handle_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Fence fence;
FenceImportFlagsKHR flags;
ExternalFenceHandleTypeFlagBitsKHR handleType;
struct ImportFenceFdInfoKHR
{
ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
- : sType( StructureType::eImportFenceFdInfoKHR )
- , pNext( nullptr )
- , fence( fence_ )
+ : fence( fence_ )
, flags( flags_ )
, handleType( handleType_ )
, fd( fd_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eImportFenceFdInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Fence fence;
FenceImportFlagsKHR flags;
ExternalFenceHandleTypeFlagBitsKHR handleType;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSurfaceCapabilities2EXT;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t minImageCount;
uint32_t maxImageCount;
Extent2D currentExtent;
struct SwapchainCounterCreateInfoEXT
{
SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
- : sType( StructureType::eSwapchainCounterCreateInfoEXT )
- , pNext( nullptr )
- , surfaceCounters( surfaceCounters_ )
+ : surfaceCounters( surfaceCounters_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SurfaceCounterFlagsEXT surfaceCounters;
};
static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
struct DisplayPowerInfoEXT
{
DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
- : sType( StructureType::eDisplayPowerInfoEXT )
- , pNext( nullptr )
- , powerState( powerState_ )
+ : powerState( powerState_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDisplayPowerInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DisplayPowerStateEXT powerState;
};
static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
struct DeviceEventInfoEXT
{
DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
- : sType( StructureType::eDeviceEventInfoEXT )
- , pNext( nullptr )
- , deviceEvent( deviceEvent_ )
+ : deviceEvent( deviceEvent_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceEventInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceEventTypeEXT deviceEvent;
};
static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
struct DisplayEventInfoEXT
{
DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
- : sType( StructureType::eDisplayEventInfoEXT )
- , pNext( nullptr )
- , displayEvent( displayEvent_ )
+ : displayEvent( displayEvent_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDisplayEventInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DisplayEventTypeEXT displayEvent;
};
static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
struct MemoryAllocateFlagsInfoKHX
{
MemoryAllocateFlagsInfoKHX( MemoryAllocateFlagsKHX flags_ = MemoryAllocateFlagsKHX(), uint32_t deviceMask_ = 0 )
- : sType( StructureType::eMemoryAllocateFlagsInfoKHX )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, deviceMask( deviceMask_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eMemoryAllocateFlagsInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
MemoryAllocateFlagsKHX flags;
uint32_t deviceMask;
};
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
DeviceGroupPresentModeFlagsKHX modes;
};
struct DeviceGroupPresentInfoKHX
{
DeviceGroupPresentInfoKHX( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, DeviceGroupPresentModeFlagBitsKHX mode_ = DeviceGroupPresentModeFlagBitsKHX::eLocal )
- : sType( StructureType::eDeviceGroupPresentInfoKHX )
- , pNext( nullptr )
- , swapchainCount( swapchainCount_ )
+ : swapchainCount( swapchainCount_ )
, pDeviceMasks( pDeviceMasks_ )
, mode( mode_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupPresentInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t swapchainCount;
const uint32_t* pDeviceMasks;
DeviceGroupPresentModeFlagBitsKHX mode;
struct DeviceGroupSwapchainCreateInfoKHX
{
DeviceGroupSwapchainCreateInfoKHX( DeviceGroupPresentModeFlagsKHX modes_ = DeviceGroupPresentModeFlagsKHX() )
- : sType( StructureType::eDeviceGroupSwapchainCreateInfoKHX )
- , pNext( nullptr )
- , modes( modes_ )
+ : modes( modes_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
DeviceGroupPresentModeFlagsKHX modes;
};
static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHX ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
struct SwapchainCreateInfoKHR
{
SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), SurfaceKHR surface_ = SurfaceKHR(), uint32_t minImageCount_ = 0, Format imageFormat_ = Format::eUndefined, ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, Extent2D imageExtent_ = Extent2D(), uint32_t imageArrayLayers_ = 0, ImageUsageFlags imageUsage_ = ImageUsageFlags(), SharingMode imageSharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, Bool32 clipped_ = 0, SwapchainKHR oldSwapchain_ = SwapchainKHR() )
- : sType( StructureType::eSwapchainCreateInfoKHR )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, surface( surface_ )
, minImageCount( minImageCount_ )
, imageFormat( imageFormat_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSwapchainCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SwapchainCreateFlagsKHR flags;
SurfaceKHR surface;
uint32_t minImageCount;
struct PipelineViewportSwizzleStateCreateInfoNV
{
PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
- : sType( StructureType::ePipelineViewportSwizzleStateCreateInfoNV )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, viewportCount( viewportCount_ )
, pViewportSwizzles( pViewportSwizzles_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineViewportSwizzleStateCreateFlagsNV flags;
uint32_t viewportCount;
const ViewportSwizzleNV* pViewportSwizzles;
struct PipelineDiscardRectangleStateCreateInfoEXT
{
PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const Rect2D* pDiscardRectangles_ = nullptr )
- : sType( StructureType::ePipelineDiscardRectangleStateCreateInfoEXT )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, discardRectangleMode( discardRectangleMode_ )
, discardRectangleCount( discardRectangleCount_ )
, pDiscardRectangles( pDiscardRectangles_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineDiscardRectangleStateCreateFlagsEXT flags;
DiscardRectangleModeEXT discardRectangleMode;
uint32_t discardRectangleCount;
struct RenderPassCreateInfo
{
RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, const AttachmentDescription* pAttachments_ = nullptr, uint32_t subpassCount_ = 0, const SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const SubpassDependency* pDependencies_ = nullptr )
- : sType( StructureType::eRenderPassCreateInfo )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, attachmentCount( attachmentCount_ )
, pAttachments( pAttachments_ )
, subpassCount( subpassCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eRenderPassCreateInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
RenderPassCreateFlags flags;
uint32_t attachmentCount;
const AttachmentDescription* pAttachments;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDevicePointClippingPropertiesKHR;
public:
- void* pNext;
+ void* pNext = nullptr;
PointClippingBehaviorKHR pointClippingBehavior;
};
static_assert( sizeof( PhysicalDevicePointClippingPropertiesKHR ) == sizeof( VkPhysicalDevicePointClippingPropertiesKHR ), "struct and wrapper have different size!" );
struct SamplerReductionModeCreateInfoEXT
{
SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
- : sType( StructureType::eSamplerReductionModeCreateInfoEXT )
- , pNext( nullptr )
- , reductionMode( reductionMode_ )
+ : reductionMode( reductionMode_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
SamplerReductionModeEXT reductionMode;
};
static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
struct PipelineTessellationDomainOriginStateCreateInfoKHR
{
PipelineTessellationDomainOriginStateCreateInfoKHR( TessellationDomainOriginKHR domainOrigin_ = TessellationDomainOriginKHR::eUpperLeft )
- : sType( StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR )
- , pNext( nullptr )
- , domainOrigin( domainOrigin_ )
+ : domainOrigin( domainOrigin_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
TessellationDomainOriginKHR domainOrigin;
};
static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfoKHR ), "struct and wrapper have different size!" );
struct SamplerYcbcrConversionCreateInfoKHR
{
SamplerYcbcrConversionCreateInfoKHR( Format format_ = Format::eUndefined, SamplerYcbcrModelConversionKHR ycbcrModel_ = SamplerYcbcrModelConversionKHR::eRgbIdentity, SamplerYcbcrRangeKHR ycbcrRange_ = SamplerYcbcrRangeKHR::eItuFull, ComponentMapping components_ = ComponentMapping(), ChromaLocationKHR xChromaOffset_ = ChromaLocationKHR::eCositedEven, ChromaLocationKHR yChromaOffset_ = ChromaLocationKHR::eCositedEven, Filter chromaFilter_ = Filter::eNearest, Bool32 forceExplicitReconstruction_ = 0 )
- : sType( StructureType::eSamplerYcbcrConversionCreateInfoKHR )
- , pNext( nullptr )
- , format( format_ )
+ : format( format_ )
, ycbcrModel( ycbcrModel_ )
, ycbcrRange( ycbcrRange_ )
, components( components_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfoKHR;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Format format;
SamplerYcbcrModelConversionKHR ycbcrModel;
SamplerYcbcrRangeKHR ycbcrRange;
struct PipelineColorBlendAdvancedStateCreateInfoEXT
{
PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, Bool32 dstPremultiplied_ = 0, BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
- : sType( StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT )
- , pNext( nullptr )
- , srcPremultiplied( srcPremultiplied_ )
+ : srcPremultiplied( srcPremultiplied_ )
, dstPremultiplied( dstPremultiplied_ )
, blendOverlap( blendOverlap_ )
{
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
Bool32 srcPremultiplied;
Bool32 dstPremultiplied;
BlendOverlapEXT blendOverlap;
struct PipelineCoverageModulationStateCreateInfoNV
{
PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr )
- : sType( StructureType::ePipelineCoverageModulationStateCreateInfoNV )
- , pNext( nullptr )
- , flags( flags_ )
+ : flags( flags_ )
, coverageModulationMode( coverageModulationMode_ )
, coverageModulationTableEnable( coverageModulationTableEnable_ )
, coverageModulationTableCount( coverageModulationTableCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
public:
- const void* pNext;
+ const void* pNext = nullptr;
PipelineCoverageModulationStateCreateFlagsNV flags;
CoverageModulationModeNV coverageModulationMode;
Bool32 coverageModulationTableEnable;
struct DeviceQueueGlobalPriorityCreateInfoEXT
{
DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
- : sType( StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT )
- , pNext( nullptr )
- , globalPriority( globalPriority_ )
+ : globalPriority( globalPriority_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
public:
- const void* pNext;
+ const void* pNext = nullptr;
QueueGlobalPriorityEXT globalPriority;
};
static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
+ enum class ConservativeRasterizationModeEXT
+ {
+ eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
+ eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
+ eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
+ };
+
+ struct PipelineRasterizationConservativeStateCreateInfoEXT
+ {
+ PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(), ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_ = 0 )
+ : flags( flags_ )
+ , conservativeRasterizationMode( conservativeRasterizationMode_ )
+ , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
+ {
+ }
+
+ PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+ }
+
+ PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
+ {
+ memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
+ return *this;
+ }
+ PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ )
+ {
+ pNext = pNext_;
+ return *this;
+ }
+
+ PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
+ {
+ flags = flags_;
+ return *this;
+ }
+
+ PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
+ {
+ conservativeRasterizationMode = conservativeRasterizationMode_;
+ return *this;
+ }
+
+ PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ )
+ {
+ extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
+ return *this;
+ }
+
+ operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const
+ {
+ return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
+ }
+
+ bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
+ {
+ return ( sType == rhs.sType )
+ && ( pNext == rhs.pNext )
+ && ( flags == rhs.flags )
+ && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode )
+ && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
+ }
+
+ bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
+ {
+ return !operator==( rhs );
+ }
+
+ private:
+ StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
+
+ public:
+ const void* pNext = nullptr;
+ PipelineRasterizationConservativeStateCreateFlagsEXT flags;
+ ConservativeRasterizationModeEXT conservativeRasterizationMode;
+ float extraPrimitiveOverestimationSize;
+ };
+ static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
+
Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties );
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<LayerProperties>>
{}
VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer )
- : m_commandBuffer( commandBuffer )
+ : m_commandBuffer( commandBuffer )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
struct SubmitInfo
{
SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, const PipelineStageFlags* pWaitDstStageMask_ = nullptr, uint32_t commandBufferCount_ = 0, const CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
- : sType( StructureType::eSubmitInfo )
- , pNext( nullptr )
- , waitSemaphoreCount( waitSemaphoreCount_ )
+ : waitSemaphoreCount( waitSemaphoreCount_ )
, pWaitSemaphores( pWaitSemaphores_ )
, pWaitDstStageMask( pWaitDstStageMask_ )
, commandBufferCount( commandBufferCount_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eSubmitInfo;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t waitSemaphoreCount;
const Semaphore* pWaitSemaphores;
const PipelineStageFlags* pWaitDstStageMask;
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue )
- : m_queue( queue )
+ : m_queue( queue )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class BufferDeleter;
- using UniqueBuffer = UniqueHandle<Buffer, BufferDeleter>;
+ template <> class UniqueHandleTraits<Buffer> {public: using deleter = BufferDeleter; };
+ using UniqueBuffer = UniqueHandle<Buffer>;
class BufferViewDeleter;
- using UniqueBufferView = UniqueHandle<BufferView, BufferViewDeleter>;
+ template <> class UniqueHandleTraits<BufferView> {public: using deleter = BufferViewDeleter; };
+ using UniqueBufferView = UniqueHandle<BufferView>;
class CommandBufferDeleter;
- using UniqueCommandBuffer = UniqueHandle<CommandBuffer, CommandBufferDeleter>;
+ template <> class UniqueHandleTraits<CommandBuffer> {public: using deleter = CommandBufferDeleter; };
+ using UniqueCommandBuffer = UniqueHandle<CommandBuffer>;
class CommandPoolDeleter;
- using UniqueCommandPool = UniqueHandle<CommandPool, CommandPoolDeleter>;
+ template <> class UniqueHandleTraits<CommandPool> {public: using deleter = CommandPoolDeleter; };
+ using UniqueCommandPool = UniqueHandle<CommandPool>;
class DescriptorPoolDeleter;
- using UniqueDescriptorPool = UniqueHandle<DescriptorPool, DescriptorPoolDeleter>;
+ template <> class UniqueHandleTraits<DescriptorPool> {public: using deleter = DescriptorPoolDeleter; };
+ using UniqueDescriptorPool = UniqueHandle<DescriptorPool>;
class DescriptorSetDeleter;
- using UniqueDescriptorSet = UniqueHandle<DescriptorSet, DescriptorSetDeleter>;
+ template <> class UniqueHandleTraits<DescriptorSet> {public: using deleter = DescriptorSetDeleter; };
+ using UniqueDescriptorSet = UniqueHandle<DescriptorSet>;
class DescriptorSetLayoutDeleter;
- using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, DescriptorSetLayoutDeleter>;
+ template <> class UniqueHandleTraits<DescriptorSetLayout> {public: using deleter = DescriptorSetLayoutDeleter; };
+ using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout>;
class DescriptorUpdateTemplateKHRDeleter;
- using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplateKHR, DescriptorUpdateTemplateKHRDeleter>;
+ template <> class UniqueHandleTraits<DescriptorUpdateTemplateKHR> {public: using deleter = DescriptorUpdateTemplateKHRDeleter; };
+ using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplateKHR>;
class DeviceMemoryDeleter;
- using UniqueDeviceMemory = UniqueHandle<DeviceMemory, DeviceMemoryDeleter>;
+ template <> class UniqueHandleTraits<DeviceMemory> {public: using deleter = DeviceMemoryDeleter; };
+ using UniqueDeviceMemory = UniqueHandle<DeviceMemory>;
class EventDeleter;
- using UniqueEvent = UniqueHandle<Event, EventDeleter>;
+ template <> class UniqueHandleTraits<Event> {public: using deleter = EventDeleter; };
+ using UniqueEvent = UniqueHandle<Event>;
class FenceDeleter;
- using UniqueFence = UniqueHandle<Fence, FenceDeleter>;
+ template <> class UniqueHandleTraits<Fence> {public: using deleter = FenceDeleter; };
+ using UniqueFence = UniqueHandle<Fence>;
class FramebufferDeleter;
- using UniqueFramebuffer = UniqueHandle<Framebuffer, FramebufferDeleter>;
+ template <> class UniqueHandleTraits<Framebuffer> {public: using deleter = FramebufferDeleter; };
+ using UniqueFramebuffer = UniqueHandle<Framebuffer>;
class ImageDeleter;
- using UniqueImage = UniqueHandle<Image, ImageDeleter>;
+ template <> class UniqueHandleTraits<Image> {public: using deleter = ImageDeleter; };
+ using UniqueImage = UniqueHandle<Image>;
class ImageViewDeleter;
- using UniqueImageView = UniqueHandle<ImageView, ImageViewDeleter>;
+ template <> class UniqueHandleTraits<ImageView> {public: using deleter = ImageViewDeleter; };
+ using UniqueImageView = UniqueHandle<ImageView>;
class IndirectCommandsLayoutNVXDeleter;
- using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX, IndirectCommandsLayoutNVXDeleter>;
+ template <> class UniqueHandleTraits<IndirectCommandsLayoutNVX> {public: using deleter = IndirectCommandsLayoutNVXDeleter; };
+ using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX>;
class ObjectTableNVXDeleter;
- using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX, ObjectTableNVXDeleter>;
+ template <> class UniqueHandleTraits<ObjectTableNVX> {public: using deleter = ObjectTableNVXDeleter; };
+ using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX>;
class PipelineDeleter;
- using UniquePipeline = UniqueHandle<Pipeline, PipelineDeleter>;
+ template <> class UniqueHandleTraits<Pipeline> {public: using deleter = PipelineDeleter; };
+ using UniquePipeline = UniqueHandle<Pipeline>;
class PipelineCacheDeleter;
- using UniquePipelineCache = UniqueHandle<PipelineCache, PipelineCacheDeleter>;
+ template <> class UniqueHandleTraits<PipelineCache> {public: using deleter = PipelineCacheDeleter; };
+ using UniquePipelineCache = UniqueHandle<PipelineCache>;
class PipelineLayoutDeleter;
- using UniquePipelineLayout = UniqueHandle<PipelineLayout, PipelineLayoutDeleter>;
+ template <> class UniqueHandleTraits<PipelineLayout> {public: using deleter = PipelineLayoutDeleter; };
+ using UniquePipelineLayout = UniqueHandle<PipelineLayout>;
class QueryPoolDeleter;
- using UniqueQueryPool = UniqueHandle<QueryPool, QueryPoolDeleter>;
+ template <> class UniqueHandleTraits<QueryPool> {public: using deleter = QueryPoolDeleter; };
+ using UniqueQueryPool = UniqueHandle<QueryPool>;
class RenderPassDeleter;
- using UniqueRenderPass = UniqueHandle<RenderPass, RenderPassDeleter>;
+ template <> class UniqueHandleTraits<RenderPass> {public: using deleter = RenderPassDeleter; };
+ using UniqueRenderPass = UniqueHandle<RenderPass>;
class SamplerDeleter;
- using UniqueSampler = UniqueHandle<Sampler, SamplerDeleter>;
+ template <> class UniqueHandleTraits<Sampler> {public: using deleter = SamplerDeleter; };
+ using UniqueSampler = UniqueHandle<Sampler>;
class SamplerYcbcrConversionKHRDeleter;
- using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversionKHR, SamplerYcbcrConversionKHRDeleter>;
+ template <> class UniqueHandleTraits<SamplerYcbcrConversionKHR> {public: using deleter = SamplerYcbcrConversionKHRDeleter; };
+ using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversionKHR>;
class SemaphoreDeleter;
- using UniqueSemaphore = UniqueHandle<Semaphore, SemaphoreDeleter>;
+ template <> class UniqueHandleTraits<Semaphore> {public: using deleter = SemaphoreDeleter; };
+ using UniqueSemaphore = UniqueHandle<Semaphore>;
class ShaderModuleDeleter;
- using UniqueShaderModule = UniqueHandle<ShaderModule, ShaderModuleDeleter>;
+ template <> class UniqueHandleTraits<ShaderModule> {public: using deleter = ShaderModuleDeleter; };
+ using UniqueShaderModule = UniqueHandle<ShaderModule>;
class SwapchainKHRDeleter;
- using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, SwapchainKHRDeleter>;
+ template <> class UniqueHandleTraits<SwapchainKHR> {public: using deleter = SwapchainKHRDeleter; };
+ using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR>;
class ValidationCacheEXTDeleter;
- using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, ValidationCacheEXTDeleter>;
+ template <> class UniqueHandleTraits<ValidationCacheEXT> {public: using deleter = ValidationCacheEXTDeleter; };
+ using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Device
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device )
- : m_device( device )
+ : m_device( device )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
, m_allocator( allocator )
{}
- void operator()( Buffer buffer )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Buffer buffer )
{
m_device.destroyBuffer( buffer, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( BufferView bufferView )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( BufferView bufferView )
{
m_device.destroyBufferView( bufferView, m_allocator );
}
, m_commandPool( commandPool )
{}
- void operator()( CommandBuffer commandBuffer )
+ Device getDevice() const { return m_device; }
+ CommandPool getCommandPool() const { return m_commandPool; }
+
+ protected:
+ void destroy( CommandBuffer commandBuffer )
{
m_device.freeCommandBuffers( m_commandPool, commandBuffer );
}
, m_allocator( allocator )
{}
- void operator()( CommandPool commandPool )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( CommandPool commandPool )
{
m_device.destroyCommandPool( commandPool, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( DescriptorPool descriptorPool )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( DescriptorPool descriptorPool )
{
m_device.destroyDescriptorPool( descriptorPool, m_allocator );
}
, m_descriptorPool( descriptorPool )
{}
- void operator()( DescriptorSet descriptorSet )
+ Device getDevice() const { return m_device; }
+ DescriptorPool getDescriptorPool() const { return m_descriptorPool; }
+
+ protected:
+ void destroy( DescriptorSet descriptorSet )
{
m_device.freeDescriptorSets( m_descriptorPool, descriptorSet );
}
, m_allocator( allocator )
{}
- void operator()( DescriptorSetLayout descriptorSetLayout )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( DescriptorSetLayout descriptorSetLayout )
{
m_device.destroyDescriptorSetLayout( descriptorSetLayout, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( DescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( DescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
{
m_device.destroyDescriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( DeviceMemory deviceMemory )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( DeviceMemory deviceMemory )
{
m_device.freeMemory( deviceMemory, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Event event )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Event event )
{
m_device.destroyEvent( event, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Fence fence )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Fence fence )
{
m_device.destroyFence( fence, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Framebuffer framebuffer )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Framebuffer framebuffer )
{
m_device.destroyFramebuffer( framebuffer, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Image image )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Image image )
{
m_device.destroyImage( image, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( ImageView imageView )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( ImageView imageView )
{
m_device.destroyImageView( imageView, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( IndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( IndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
{
m_device.destroyIndirectCommandsLayoutNVX( indirectCommandsLayoutNVX, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( ObjectTableNVX objectTableNVX )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( ObjectTableNVX objectTableNVX )
{
m_device.destroyObjectTableNVX( objectTableNVX, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Pipeline pipeline )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Pipeline pipeline )
{
m_device.destroyPipeline( pipeline, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( PipelineCache pipelineCache )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( PipelineCache pipelineCache )
{
m_device.destroyPipelineCache( pipelineCache, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( PipelineLayout pipelineLayout )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( PipelineLayout pipelineLayout )
{
m_device.destroyPipelineLayout( pipelineLayout, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( QueryPool queryPool )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( QueryPool queryPool )
{
m_device.destroyQueryPool( queryPool, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( RenderPass renderPass )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( RenderPass renderPass )
{
m_device.destroyRenderPass( renderPass, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Sampler sampler )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Sampler sampler )
{
m_device.destroySampler( sampler, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( SamplerYcbcrConversionKHR samplerYcbcrConversionKHR )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( SamplerYcbcrConversionKHR samplerYcbcrConversionKHR )
{
m_device.destroySamplerYcbcrConversionKHR( samplerYcbcrConversionKHR, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( Semaphore semaphore )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Semaphore semaphore )
{
m_device.destroySemaphore( semaphore, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( ShaderModule shaderModule )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( ShaderModule shaderModule )
{
m_device.destroyShaderModule( shaderModule, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( SwapchainKHR swapchainKHR )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( SwapchainKHR swapchainKHR )
{
m_device.destroySwapchainKHR( swapchainKHR, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( ValidationCacheEXT validationCacheEXT )
+ Device getDevice() const { return m_device; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( ValidationCacheEXT validationCacheEXT )
{
m_device.destroyValidationCacheEXT( validationCacheEXT, m_allocator );
}
{
std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
uint32_t presentationTimingCount;
- Result result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
- if ( ( result == Result::eSuccess ) && presentationTimingCount )
+ Result result;
+ do
{
- presentationTimings.resize( presentationTimingCount );
- result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
- }
+ result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
+ if ( ( result == Result::eSuccess ) && presentationTimingCount )
+ {
+ presentationTimings.resize( presentationTimingCount );
+ result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
+ }
+ } while ( result == Result::eIncomplete );
+ assert( presentationTimingCount <= presentationTimings.size() );
+ presentationTimings.resize( presentationTimingCount );
return createResultValue( result, presentationTimings, "VULKAN_HPP_NAMESPACE::Device::getPastPresentationTimingGOOGLE" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class DeviceDeleter;
- using UniqueDevice = UniqueHandle<Device, DeviceDeleter>;
+ template <> class UniqueHandleTraits<Device> {public: using deleter = DeviceDeleter; };
+ using UniqueDevice = UniqueHandle<Device>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class PhysicalDevice
{}
VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice )
- : m_physicalDevice( physicalDevice )
+ : m_physicalDevice( physicalDevice )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
: m_allocator( allocator )
{}
- void operator()( Device device )
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Device device )
{
device.destroy( m_allocator );
}
struct CmdProcessCommandsInfoNVX
{
CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t indirectCommandsTokenCount_ = 0, const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, uint32_t maxSequencesCount_ = 0, CommandBuffer targetCommandBuffer_ = CommandBuffer(), Buffer sequencesCountBuffer_ = Buffer(), DeviceSize sequencesCountOffset_ = 0, Buffer sequencesIndexBuffer_ = Buffer(), DeviceSize sequencesIndexOffset_ = 0 )
- : sType( StructureType::eCmdProcessCommandsInfoNVX )
- , pNext( nullptr )
- , objectTable( objectTable_ )
+ : objectTable( objectTable_ )
, indirectCommandsLayout( indirectCommandsLayout_ )
, indirectCommandsTokenCount( indirectCommandsTokenCount_ )
, pIndirectCommandsTokens( pIndirectCommandsTokens_ )
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
ObjectTableNVX objectTable;
IndirectCommandsLayoutNVX indirectCommandsLayout;
uint32_t indirectCommandsTokenCount;
}
private:
- StructureType sType;
+ StructureType sType = StructureType::ePhysicalDeviceGroupPropertiesKHX;
public:
- void* pNext;
+ void* pNext = nullptr;
uint32_t physicalDeviceCount;
PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
Bool32 subsetAllocation;
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class DebugReportCallbackEXTDeleter;
- using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, DebugReportCallbackEXTDeleter>;
+ template <> class UniqueHandleTraits<DebugReportCallbackEXT> {public: using deleter = DebugReportCallbackEXTDeleter; };
+ using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT>;
class SurfaceKHRDeleter;
- using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, SurfaceKHRDeleter>;
+ template <> class UniqueHandleTraits<SurfaceKHR> {public: using deleter = SurfaceKHRDeleter; };
+ using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Instance
{}
VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance )
- : m_instance( instance )
+ : m_instance( instance )
{}
#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
, m_allocator( allocator )
{}
- void operator()( DebugReportCallbackEXT debugReportCallbackEXT )
+ Instance getInstance() const { return m_instance; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( DebugReportCallbackEXT debugReportCallbackEXT )
{
m_instance.destroyDebugReportCallbackEXT( debugReportCallbackEXT, m_allocator );
}
, m_allocator( allocator )
{}
- void operator()( SurfaceKHR surfaceKHR )
+ Instance getInstance() const { return m_instance; }
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( SurfaceKHR surfaceKHR )
{
m_instance.destroySurfaceKHR( surfaceKHR, m_allocator );
}
struct DeviceGroupDeviceCreateInfoKHX
{
DeviceGroupDeviceCreateInfoKHX( uint32_t physicalDeviceCount_ = 0, const PhysicalDevice* pPhysicalDevices_ = nullptr )
- : sType( StructureType::eDeviceGroupDeviceCreateInfoKHX )
- , pNext( nullptr )
- , physicalDeviceCount( physicalDeviceCount_ )
+ : physicalDeviceCount( physicalDeviceCount_ )
, pPhysicalDevices( pPhysicalDevices_ )
{
}
}
private:
- StructureType sType;
+ StructureType sType = StructureType::eDeviceGroupDeviceCreateInfoKHX;
public:
- const void* pNext;
+ const void* pNext = nullptr;
uint32_t physicalDeviceCount;
const PhysicalDevice* pPhysicalDevices;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class InstanceDeleter;
- using UniqueInstance = UniqueHandle<Instance, InstanceDeleter>;
+ template <> class UniqueHandleTraits<Instance> {public: using deleter = InstanceDeleter; };
+ using UniqueInstance = UniqueHandle<Instance>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance );
: m_allocator( allocator )
{}
- void operator()( Instance instance )
+ Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
+
+ protected:
+ void destroy( Instance instance )
{
instance.destroy( m_allocator );
}
template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceConservativeRasterizationPropertiesEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfoKHX>{ enum { value = true }; };
VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits)
{
return "{}";
}
+ VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT)
+ {
+ return "(void)";
+ }
+
+ VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagsEXT)
+ {
+ return "{}";
+ }
+
VULKAN_HPP_INLINE std::string to_string(ImageLayout value)
{
switch (value)
case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV";
case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT";
case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT";
+ case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
+ case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT";
case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT";
case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR";
case StructureType::ePhysicalDeviceExternalFenceInfoKHR: return "PhysicalDeviceExternalFenceInfoKHR";
}
}
+ VULKAN_HPP_INLINE std::string to_string(ConservativeRasterizationModeEXT value)
+ {
+ switch (value)
+ {
+ case ConservativeRasterizationModeEXT::eDisabled: return "Disabled";
+ case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate";
+ case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate";
+ default: return "invalid";
+ }
+ }
+
} // namespace VULKAN_HPP_NAMESPACE
#endif
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff